?um/p1-90`位于 https://tc39.es/ecma262/ 的文档是最准确和最新的 ECMAScript 规范。它包含最新年度快照的内容以及自该快照以来的所有 已完成提案 (那些在 提案流程 中达到第4阶段的提案,因此已在多个实现中实现,将包含在下一个实际修订版中)。
本规范在 GitHub 上借助 ECMAScript 社区的帮助进行开发。有多种方式可以为本规范的开发做出贡献:
有关本文档创建方式的更多信息,请参阅
本 Ecma 标准定义了 ECMAScript 2026 语言。这是 ECMAScript 语言规范的第十七版。自 1997 年第一版发布以来,ECMAScript 已经发展成为世界上最广泛使用的通用编程语言之一。它最为人所知的是作为嵌入在 Web 浏览器中的语言,但也被广泛应用于服务器和嵌入式应用程序。
ECMAScript 基于几种原创技术,最著名的是 JavaScript(Netscape)和 JScript(Microsoft)。该语言由 Brendan Eich 在 Netscape 发明,首次出现在该公司的 Navigator 2.0 浏览器中。它出现在 Netscape 的所有后续浏览器中,以及从 Internet Explorer 3.0 开始的所有 Microsoft 浏览器中。
ECMAScript 语言规范的开发始于 1996 年 11 月。本 Ecma 标准的第一版于 1997 年 6 月由 Ecma 大会通过。
该 Ecma 标准已提交给 ISO/IEC JTC 1,按照快速通道程序通过,并于 1998 年 4 月批准为国际标准 ISO/IEC 16262。1998 年 6 月的 Ecma 大会批准了 ECMA-262 的第二版,以保持与 ISO/IEC 16262 完全一致。第一版和第二版之间的变化在性质上是编辑性的。
该标准的第三版引入了强大的正则表达式、更好的字符串处理、新的控制语句、try/catch 异常处理、更严格的错误定义、数值输出格式化以及为预期的未来语言增长而进行的小幅更改。ECMAScript 标准的第三版于 1999 年 12 月由 Ecma 大会通过,并于 2002 年 6 月作为 ISO/IEC 16262:2002 发布。
第三版发布后,ECMAScript 与万维网结合实现了大规模应用,成为几乎所有 Web 浏览器支持的编程语言。为开发 ECMAScript 第四版做了大量工作。然而,这项工作没有完成,也没有作为 ECMAScript 第四版发布,但其中一些内容被纳入了第六版的开发中。
ECMAScript 第五版(作为 ECMA-262 第 5 版发布)编纂了在浏览器实现中已经常见的语言规范的事实解释,并增加了对自第三版发布以来出现的新功能的支持。这些功能包括
第五版已提交给 ISO/IEC JTC 1,按照快速通道程序通过,并批准为国际标准 ISO/IEC 16262:2011。ECMAScript 标准的 5.1 版纳入了小幅更正,与 ISO/IEC 16262:2011 文本相同。5.1 版于 2011 年 6 月由 Ecma 大会通过。
第六版的重点开发始于 2009 年,当时第五版正在准备发布。然而,这之前进行了大量的实验和语言增强设计工作,可以追溯到 1999
年第三版的发布。从很真实的意义上说,第六版的完成是十五年努力的顶峰。这一版的目标包括为大型应用程序、库创建以及将 ECMAScript
用作其他语言的编译目标提供更好的支持。它的一些主要增强功能包括模块、类声明、词法块作用域、
ECMAScript 2016 是在 Ecma TC39 新的年度发布节奏和开放开发过程下发布的第一个 ECMAScript 版本。从 ECMAScript 2015 源文档构建了一个纯文本源文档,作为完全在
GitHub 上进一步开发的基础。在这个标准开发的一年中,提交了数百个拉取请求和问题,代表了数千个错误修复、编辑修复和其他改进。此外,还开发了许多软件工具来帮助这一工作,包括
Ecmarkup、Ecmarkdown 和 Grammarkdown。ES2016 还包括对新指数运算符的支持,并向 Array.prototype 添加了一个名为
includes 的新方法。
ECMAScript 2017 引入了异步函数、共享内存和原子操作,以及较小的语言和库增强、错误修复和编辑更新。异步函数通过为返回 promise
的函数提供语法来改善异步编程体验。共享内存和原子操作引入了新的Object.values、Object.entries 和
Object.getOwnPropertyDescriptors。
ECMAScript 2018 通过dotAll
标志、命名捕获组、Unicode 属性转义和后行断言。最后,它包括对象 rest 和展开属性。
ECMAScript 2019 引入了一些新的内置函数:Array.prototype 上用于扁平化数组的 flat 和
flatMap,用于直接将 Object.entries 的返回值转换为新 Object 的
Object.fromEntries,以及 String.prototype 上的 trimStart 和
trimEnd,作为广泛实现但非标准的 String.prototype.trimLeft 和 trimRight
内置功能的更好命名替代品。此外,它还包括语法和语义的一些小更新。更新的语法包括可选的 catch 绑定参数,以及允许在字符串字面量中使用 U+2028(行分隔符)和 U+2029(段落分隔符)以与 JSON
保持一致。其他更新包括要求 Array.prototype.sort 为稳定排序,要求 JSON.stringify 无论输入如何都返回格式良好的
UTF-8,以及通过要求它返回相应的原始源文本或标准占位符来澄清 Function.prototype.toString。
ECMAScript 2020,第 11 版,为字符串引入了 matchAll 方法,为全局正则表达式生成的所有匹配对象产生一个import(),一种使用动态说明符异步导入模块的语法;BigInt,用于处理任意精度Promise.allSettled,一个不会短路的新 Promise
组合器;globalThis,访问全局 this 值的通用方式;专用的 export * as ns from 'module'
语法,用于在模块内使用;增加了 for-in 枚举顺序的标准化;import.meta,一个在模块中可用的
ECMAScript 2021,第 12 版,为字符串引入了 replaceAll 方法;Promise.any,一个在输入值被满足时短路的 Promise
组合器;AggregateError,一个同时表示多个错误的新 Error
类型;逻辑赋值运算符(??=、&&=、||=);WeakRef,用于引用目标对象而不阻止其被垃圾回收,以及
FinalizationRegistry,用于管理目标对象被垃圾回收时执行的清理操作的注册和注销;数字字面量的分隔符(1_000);以及
Array.prototype.sort 变得更加精确,减少了导致
ECMAScript 2022,第 13 版,引入了顶级 await,允许在模块顶级使用该#x in obj
语法,用于测试对象上私有字段的存在;通过 /d 标志的正则表达式匹配索引,提供匹配子字符串的开始和结束索引;Error 对象上的
cause 属性,可用于在错误中记录因果链;字符串、数组和 at 方法,允许相对索引;以及
Object.hasOwn,Object.prototype.hasOwnProperty 的便捷替代品。
ECMAScript 2023,第 14 版,在 Array.prototype 和 TypedArray.prototype 上引入了
toSorted、toReversed、with、findLast 和
findLastIndex 方法,以及 Array.prototype 上的 toSpliced 方法;增加了对文件开头
#! 注释的支持,以更好地促进可执行的 ECMAScript 文件;并允许在弱集合中使用大多数 Symbol 作为键。
ECMAScript 2024,第 15 版,增加了调整大小和传输 ArrayBuffer 和 SharedArrayBuffer 的功能;增加了新的 RegExp /v
标志,用于创建具有更高级功能的 RegExp 以处理字符串集合;并引入了用于构造 Promise 的 Promise.withResolvers 便捷方法,用于聚合数据的
Object.groupBy 和 Map.groupBy 方法,用于异步等待共享内存更改的 Atomics.waitAsync
方法,以及用于检查和确保字符串仅包含格式良好的 Unicode 的 String.prototype.isWellFormed 和
String.prototype.toWellFormed 方法。
ECMAScript 2025,第 16 版,添加了一个新的 Iterator 全局对象,带有相关的静态和原型方法,用于处理Set.prototype 添加了用于对 Set 执行常见操作的方法;增加了对导入 JSON 模块的支持以及用于声明导入模块属性的语法;添加了用于转义字符串以在正则表达式中安全使用的
RegExp.escape 方法;添加了用于在正则表达式内内联启用和禁用修饰符标志的语法;添加了用于调用可能返回或可能不返回 Promise
的函数并确保结果始终为 Promise 的 Promise.try 方法;并添加了新的 Float16Array
DataView.prototype.getFloat16、DataView.prototype.setFloat16 和
Math.f16round 方法。
代表众多组织的数十名个人在 Ecma TC39 内对本版本和以前版本的开发做出了非常重要的贡献。此外,已经形成了一个充满活力的社区来支持 TC39 的 ECMAScript 工作。这个社区审查了许多草案,提交了数千个错误报告,进行了实现实验,贡献了测试套件,并向全球开发者社区介绍了 ECMAScript。不幸的是,无法识别和承认每个为这一努力做出贡献的个人和组织。
Allen Wirfs-Brock
ECMA-262,项目编辑,第 6 版
Brian Terlson
ECMA-262,项目编辑,第 7 至第 10 版
Jordan Harband
ECMA-262,项目编辑,第 10 至第 12 版
Shu-yu Guo
ECMA-262,项目编辑,第 12 至第 16 版
Michael Ficarra
ECMA-262,项目编辑,第 12 至第 16 版
Kevin Gibbons
ECMA-262,项目编辑,第 12 至第 16 版
本标准定义了 ECMAScript 2026 通用编程语言。
ECMAScript 的一致性实现必须提供并支持本规范中描述的所有类型、值、对象、属性、函数以及程序语法和语义。
ECMAScript 的一致性实现必须按照最新版本的 Unicode 标准和 ISO/IEC 10646 来解释源文本输入。
提供应用程序编程接口 (API) 的 ECMAScript 一致性实现,如果该 API 支持需要适应不同人类语言和国家使用的语言和文化约定的程序,则必须实现与本规范兼容的最新版本 ECMA-402 中定义的接口。
ECMAScript 的一致性实现可以提供本规范中描述的类型、值、对象、属性和函数之外的其他类型、值、对象、属性和函数。特别是,ECMAScript 的一致性实现可以为本规范中描述的对象提供本规范中未描述的属性以及这些属性的值。
ECMAScript 的一致性实现可以支持本规范中未描述的程序和正则表达式语法。特别是,ECMAScript 的一致性实现可以支持使用本规范子条款
ECMAScript 的一致性实现不得实现子条款
ECMAScript 的一致性实现不得重新定义任何不是
ECMAScript 的一致性实现可以选择实现或不实现规范可选子条款。如果实现了任何规范可选行为,则必须实现包含规范可选条款中的所有行为。规范可选条款在本规范中用彩色框中的"规范可选"字样表示,如下所示。
示例条款内容。
ECMAScript 的一致性实现必须实现遗留子条款,除非它们也被标记为规范可选。遗留子条款中指定的所有语言功能和行为都具有一个或多个不良特征。然而,它们在现有应用程序中的持续使用阻止了它们从本规范中被移除。这些功能不被视为核心 ECMAScript 语言的一部分。程序员在编写新的 ECMAScript 代码时不应使用或假设这些功能和行为的存在。
示例条款内容。
示例条款内容。
以下引用文档对于本文档的应用是必不可少的。对于注明日期的引用,只适用所引用的版本。对于未注明日期的引用,适用引用文档的最新版本(包括任何修订)。
Unicode 标准。
https://unicode.org/versions/latest
ISO/IEC 10646,信息技术 — 通用多八位编码字符集 (UCS) 加上修订 1:2005、修订 2:2006、修订 3:2008、修订 4:2008,以及其他修订和勘误,或后续版本。
ECMA-402,ECMAScript 国际化 API 规范,特指与本规范版本对应的年度版本。
https://www.ecma-international.org/publications-and-standards/standards/ecma-402/
ECMA-404,JSON 数据交换格式。
https://www.ecma-international.org/publications-and-standards/standards/ecma-404/
本节包含对 ECMAScript 语言的非规范性概述。
ECMAScript 是一种面向对象的编程语言,用于在
ECMAScript
最初被设计用作脚本语言,但现已广泛用作通用编程语言。脚本语言是一种编程语言,用于操作、自定义和自动化现有系统的设施。在这样的系统中,有用的功能已经通过用户界面可用,脚本语言是将该功能暴露给程序控制的机制。通过这种方式,现有系统被称为提供对象和设施的
ECMAScript 最初被设计为Web 脚本语言,提供在浏览器中活跃网页并作为基于 Web 的客户端-服务器架构的一部分执行服务器计算的机制。ECMAScript
现在用于为各种
ECMAScript 的使用已经超越了简单的脚本编写,现在用于许多不同环境和规模中编程任务的全谱。随着 ECMAScript 使用的扩展,它提供的功能和设施也在扩展。ECMAScript 现在是一种功能齐全的通用编程语言。
Web 浏览器为客户端计算提供 ECMAScript
Web 服务器为服务器端计算提供不同的
每个支持 ECMAScript 的 Web 浏览器和服务器都提供自己的
为了帮助将 ECMAScript 集成到
实现是进一步定义附录
实现定义设施是将其定义推迟到外部来源而无需进一步限定的设施。本规范不对特定行为提出任何建议,符合规范的实现可以在本规范提出的约束内自由选择任何行为。
实现近似设施是将其定义推迟到外部来源同时推荐理想行为的设施。虽然符合规范的实现可以在本规范提出的约束内自由选择任何行为,但鼓励它们努力接近理想。某些数学运算,如Math.exp
宿主是进一步定义附录
宿主钩子是全部或部分由外部来源定义的抽象操作。所有
宿主定义设施是将其定义推迟到外部来源而无需进一步限定并在附录
宿主环境是对所有
以下是 ECMAScript 的非正式概述——并非语言的所有部分都被描述。这个概述不是标准本身的一部分。
ECMAScript 是基于对象的:基本语言和
ECMAScript 定义了一个内置对象集合,完善了 ECMAScript 实体的定义。这些内置对象包括Object、Function、Boolean、Symbol 和各种
Error 对象;表示和操作数值的对象,包括 Math、Number 和
Date;文本处理对象 String 和 RegExp;作为值的索引集合的对象,包括
Array 和九种不同类型的类型化数组,其元素都有特定的数值数据表示;键值集合,包括 Map 和
Set 对象;支持结构化数据的对象,包括 JSON
对象、ArrayBuffer、SharedArrayBuffer
和 DataView;支持控制抽象的对象,包括生成器函数和 Promise 对象;以及反射对象,包括
Proxy 和 Reflect。
ECMAScript 还定义了一组内置操作符。ECMAScript 操作符包括各种一元运算、乘性运算符、加性运算符、按位移位运算符、关系运算符、相等运算符、二元按位运算符、二元逻辑运算符、赋值运算符和逗号运算符。
大型 ECMAScript 程序由模块支持,模块允许程序被分为多个语句和声明序列。每个模块明确标识它使用的需要由其他模块提供的声明,以及它的哪些声明可供其他模块使用。
ECMAScript 语法有意类似 Java 语法。ECMAScript 语法被放宽以使其能够作为易于使用的脚本语言。例如,变量不需要声明其类型,类型也不与属性关联,定义的函数不需要在调用之前在文本上出现其声明。
尽管 ECMAScript 包含类定义的语法,但 ECMAScript 对象在根本上不是基于类的,如 C++、Smalltalk 或 Java
中的对象。相反,对象可以通过各种方式创建,包括通过字面量表示法或通过new Date(2009, 11) 创建一个新的
Date 对象。在不使用 new 的情况下调用Date()
产生当前日期和时间的字符串表示,而不是对象。
每个由
在基于类的面向对象语言中,一般来说,状态由实例承载,方法由类承载,继承只是结构和行为的继承。在 ECMAScript 中,状态和方法由对象承载,而结构、行为和状态都被继承。
所有不直接包含其原型包含的特定属性的对象都共享该属性及其值。图 1 说明了这一点:
CF 是一个new
表达式创建了五个对象:cf1、cf2、cf3、cf4
和 cf5。这些对象中的每一个都包含名为
与大多数基于类的对象语言不同,可以通过为对象赋值来动态添加属性。也就是说,
虽然 ECMAScript 对象本质上不是基于类的,但基于
ECMAScript 语言认识到一些语言用户可能希望限制使用语言中可用的某些功能的可能性。他们可能出于安全考虑、避免他们认为容易出错的功能、获得增强的错误检查或其他他们选择的原因而这样做。为了支持这种可能性,ECMAScript 定义了语言的严格变体。语言的严格变体排除了常规 ECMAScript 语言的一些特定语法和语义功能,并修改了一些功能的详细语义。严格变体还指定了必须通过在非严格形式的语言未指定为错误的情况下抛出错误异常来报告的额外错误条件。
ECMAScript 的严格变体通常被称为语言的严格模式。严格模式的选择和使用以及 ECMAScript 的严格模式语法和语义在个别
为了符合本规范,ECMAScript 实现必须实现完整的无限制 ECMAScript 语言和本规范定义的 ECMAScript 语言的严格变体。此外,实现必须支持将无限制和严格模式源文本单元组合到单个复合程序中。
就本文档而言,以下术语和定义适用。
与
编辑上,见条款
如条款
Undefined、Null、Boolean、Number、BigInt、Symbol 或 String 类型之一的成员,如条款
原始值是在语言实现的最低级别直接表示的数据。
Object 类型的成员
对象是属性的集合,并且有一个原型对象。原型可能是
创建和初始化对象的
为其他对象提供共享属性的对象
对于所有对象必须支持的基本内部方法具有默认行为的对象
对于一个或多个基本内部方法没有默认行为的对象
语义由本规范定义的对象
由 ECMAScript 实现指定和提供的对象
标准内置对象在本规范中定义。ECMAScript 实现可以指定和提供本规范中未描述的其他类型的内置对象。
在变量未被赋值时使用的原始值
唯一值为
表示故意缺少任何对象值的原始值
唯一值为
只有两个 Boolean 值,
由原始值
Boolean 对象通过在 new 表达式中使用 Boolean
所有可能 String 值的集合
对应于双精度 64 位二进制格式
Number 值是
所有可能 Number 值的集合,包括
正无限 Number 值的 Number 值
对应于任意精度
所有可能 BigInt 值的集合
表示唯一、非 String 对象
所有可能 Symbol 值的集合
除了其属性外,函数包含可执行代码和状态,这些决定了调用时的行为。函数的代码可能用 ECMAScript 编写,也可能不是。
是函数的内置对象
内置函数的例子包括 parseInt 和 Math.exp。
是
对象的一部分,将键(String 值或 Symbol 值)与值关联
根据属性的形式,值可以直接表示为数据值(原始值、对象或
作为属性值的函数
当函数作为对象的方法调用时,对象作为其
是内置函数的方法
标准内置方法在本规范中定义。
定义属性某些特征的内部值
直接包含在其对象中的属性
对象的属性,不是自有属性但是对象原型的属性(自有或继承)
本规范的其余部分组织如下:
章节
章节
章节
章节
章节
上下文无关文法由若干产生式组成。每个产生式的左侧有一个称为非终结符的抽象符号,右侧是零个或多个非终结符和终结符符号的序列。对于每个文法,终结符都从指定的字母表中选取。
链式产生式是在其右侧恰好有一个非终结符号以及零个或多个终结符的产生式。
从一个由单一特殊非终结符组成的句子开始,称为目标符号,给定的上下文无关文法指定一种语言,即,通过反复将序列中的任何非终结符替换为以该非终结符作为左侧的产生式的右侧,可能产生的终结符序列的(可能无限的)集合。
ECMAScript 的词法文法在
除空白和注释之外的输入元素构成了 ECMAScript 句法文法的终结符,并被称为 ECMAScript 标记。这些标记是 ECMAScript 语言的/*…*/ 的注释,无论其是否跨越多行)不包含行终止符,则同样会被简单丢弃;但如果
ECMAScript 的 RegExp 文法在章节
词法文法和 RegExp 文法的产生式以两个冒号"::"作为分隔标点符号来区分。词法文法和 RegExp 文法共享一些产生式。
数值字符串文法出现在章节
数值字符串文法的产生式以三个冒号":::"作为标点符号来区分,从不用于解析源文本。
ECMAScript 的语法文法在章节
当代码点流要被解析为 ECMAScript
当解析成功时,它构造一个解析树,这是一个根树结构,其中每个节点都是一个解析节点。每个解析节点是文法中符号的一个实例;它表示可以从该符号派生的源文本范围。表示整个源文本的解析树根节点是解析的
为每次解析器调用实例化新的解析节点,即使是相同源文本的解析也从不重用。当且仅当解析节点表示相同的源文本范围、是相同文法符号的实例且来自相同的解析器调用时,才被认为是同一个解析节点。
多次解析相同的字符串将导致不同的解析节点。例如,考虑:
let str = "1 + 1;";
eval(str);
eval(str);
每次调用 eval 都将 str 的值转换为
语法文法的产生式以仅一个冒号":"作为标点符号来区分。
章节
在某些情况下,为了避免歧义,语法文法使用广义产生式,允许不构成有效 ECMAScript
在 ECMAScript 文法中,一些终结符号以 固定宽度 字体显示。
这些符号必须在源文本中完全按照所写的方式出现。以这种方式指定的所有终结符号代码点
都应理解为来自基本拉丁块的适当 Unicode 代码点,而不是来自其他 Unicode 范围的任何类似代码点。
终结符号中的代码点不能用 \
在终结符号为单个 Unicode 代码点的文法中(即词法、正则表达式和数字字符串文法), 产生式中出现的多个连续固定宽度代码点是相同代码点序列的简写, 写作独立的终结符号。
例如,产生式:
是以下的简写:
相比之下,在语法文法中,连续的固定宽度代码点是单个终结符号。
终结符号有另外两种形式:
非终结符号以 斜体 显示。非终结符的定义(也称为"产生式") 由要定义的非终结符的名称后跟一个或多个冒号引入。(冒号的数量表示产生式属于哪个文法。) 然后在后续行中跟随非终结符的一个或多个可选右侧。例如,语法定义:
表示非终结符 while,后跟左括号 token,后跟
表示
下标后缀 "opt" 可能出现在终结符或非终结符之后,表示可选符号。 包含可选符号的选择实际上指定了两个右侧,一个省略可选元素,一个包含它。这意味着:
是以下的便利缩写:
并且:
是以下的便利缩写:
这又是以下的缩写:
所以,在这个例子中,非终结符
产生式可以通过下标注释的形式 "[parameters]" 进行参数化, 该注释可以作为产生式定义的非终结符号的后缀出现。"parameters" 可以是单个名称 或用逗号分隔的名称列表。参数化产生式是一组产生式的简写, 定义了参数名称的所有组合,在下划线前面,附加到参数化非终结符号。这意味着:
是以下的便利缩写:
并且:
是以下的缩写:
多个参数产生组合数量的产生式,并非所有这些产生式都必须在完整文法中引用。
产生式右侧的非终结符引用也可以参数化。例如:
等价于说:
并且:
等价于:
非终结符引用可以同时具有参数列表和 "opt" 后缀。例如:
是以下的缩写:
在右侧非终结符引用中,使用 "?" 作为参数名称的前缀 使该参数值依赖于当前产生式左侧符号引用中该参数名称的出现。例如:
是以下的缩写:
如果右侧选择以 "[+parameter]" 为前缀,那么该选择只有在引用产生式的非终结符号时使用了命名参数才可用。 如果右侧选择以 "[~parameter]" 为前缀,那么该选择只有在引用产生式的非终结符号时 没有 使用命名参数才可用。这意味着:
是以下的缩写:
并且:
是以下的缩写:
当单词 "one of" 跟在文法定义中的冒号后面时,它们表示后续行中的每个终结符号 都是一个可选定义。例如,ECMAScript 的词法文法包含产生式:
这只是以下的便利缩写:
如果短语 "[empty]" 作为产生式的右侧出现,它表示产生式的右侧不包含终结符或非终结符。
如果短语 "[lookahead = seq]" 出现在产生式的右侧,
它表示只有当标记序列 seq 是紧随其后的输入标记序列的前缀时,才能使用该产生式。类似地,"[lookahead ∈
set]"(其中 set 是标记序列的
这些条件可以被否定。"[lookahead ≠ seq]" 表示只有当 seq 不是紧随其后的输入标记序列的前缀时,才能使用包含的产生式,而 "[lookahead ∉ set]" 表示只有当 set 中没有元素是紧随其后的标记序列的前缀时,才能使用该产生式。
作为示例,给定定义:
定义:
匹配字母 n 后跟一个或多个十进制数字(其中第一个数字是偶数),或者一个十进制数字后面不跟另一个十进制数字。
注意,当这些短语在语法文法中使用时,可能无法明确地识别紧随其后的标记序列,因为确定后续标记需要知道在后续位置使用哪个词法
如果短语 "[no
表示如果在脚本的 throw 标记和
除非受限产生式禁止出现
产生式的右侧可以通过使用短语 "but not" 然后指出要排除的展开来指定某些展开是不被允许的。例如,产生式:
意味着非终结符
最后,少数非终结符通过无衬线字体的描述性短语来描述,这是在列出所有选择不切实际的情况下:
本规范通常使用编号列表来指定算法中的步骤。这些算法用于精确指定 ECMAScript 语言构造所需的语义。这些算法并非旨在暗示使用任何特定的实现技术。实际上,可能存在更有效的算法来实现给定的特性。
算法可以使用有序的、逗号分隔的别名序列进行显式参数化,这些别名可以在算法步骤中用于引用在该位置传入的参数。可选参数用方括号([ , name
])表示,在算法步骤中与必需参数没有区别。剩余参数可以出现在参数列表的末尾,用前导省略号(, ...name)表示。剩余参数将捕获在必需参数和可选参数之后提供的所有参数到一个
算法步骤可以细分为顺序的子步骤。子步骤是缩进的,并且它们本身可以进一步划分为缩进的子步骤。使用大纲编号约定来标识子步骤,第一级子步骤用小写字母标记,第二级子步骤用小写罗马数字标记。如果需要三个以上的级别,则这些规则会重复,第四级使用数字标签。例如:
一个步骤或子步骤可以写成一个“if”谓词,该谓词对其子步骤进行条件限制。在这种情况下,仅当谓词为真时才应用子步骤。如果一个步骤或子步骤以单词“else”开头,则它是一个谓词,该谓词是同一级别上在前的“if”谓词步骤的否定。
一个步骤可以指定其子步骤的迭代应用。
以“断言:”开头的步骤断言其算法的不变条件。此类断言用于明确算法中否则将是隐式的不变量。此类断言不增加额外的语义要求,因此实现无需检查。它们仅用于阐明算法。
算法步骤可以使用“令 x 为 someValue”的形式为任何值声明命名别名。这些别名是引用式的,即 x 和 someValue 都引用相同的基础数据,对其中任何一个的修改对两者都可见。希望避免这种引用式行为的算法步骤应显式复制右侧的值:“令 x 为 someValue 的副本”会创建 someValue 的浅拷贝。
一旦声明,别名就可以在任何后续步骤中引用,并且不得在别名声明之前的步骤中引用。可以使用“将 x 设置为 someOtherValue”的形式修改别名。
为了便于在规范的多个部分中使用,一些算法(称为抽象操作)被命名并以参数化函数形式编写,以便可以从其他算法中按名称引用它们。抽象操作通常使用函数应用样式(如 OperationName(arg1, arg2))进行引用。一些抽象操作被视为类规范抽象的多态分派方法。此类方法式抽象操作通常使用方法应用样式(如 someValue.OperationName(arg1, arg2))进行引用。
语法导向操作是一种命名操作,其定义由算法组成,每个算法都与 ECMAScript
语法中的一个或多个产生式相关联。具有多个备选定义的产生式通常会为每个备选方案提供一个不同的算法。当算法与语法产生式相关联时,它可以像引用算法参数一样引用产生式备选方案的终结符和非终结符。以这种方式使用时,非终结符指的是解析源文本时匹配的实际备选定义。语法产生式或由其派生的
当算法与产生式备选方案相关联时,该备选方案通常不带任何“[ ]”语法注释。此类注释仅影响备选方案的语法识别,对备选方案的相关语义没有影响。
语法导向操作通过使用以下算法中的步骤
除非另有明确规定,否则所有
但是
运行时语义:
指定必须在运行时调用的语义的算法称为运行时语义。运行时语义由
抽象操作 Completion 接受参数 completionRecord(一个
算法步骤中说要抛出异常,例如:
与以下含义相同:
算法步骤中说或等效于:
与以下含义相同:
算法步骤中说或等效于:
与以下含义相同:
其中 hygienicTemp 是临时的,并且仅在与 ReturnIfAbrupt 相关的步骤中可见。
算法步骤中说或等效于:
与以下含义相同:
以 ? 为前缀的
等效于以下步骤:
类似地,对于方法应用样式,步骤:
等效于:
类似地,前缀 ! 用于指示以下抽象操作或
等效于以下步骤:
! 或
? 来使用此简写:
在声明返回
如果通过任何其他方式从此类抽象操作返回
与以下任何一种含义相同:
或
或
请注意,通过
以下示例将是编辑错误,因为正在返回一个
上下文无关文法不足以表达所有规则,这些规则定义输入元素流是否形成一个有效的、可以求值的 ECMAScript
静态语义规则具有名称,并且通常使用算法定义。命名的静态语义规则与语法产生式相关联,具有多个备选定义的产生式通常会为每个备选方案的每个适用的命名静态语义规则提供一个不同的算法。
一种特殊的静态语义规则是早期错误规则。
本规范引用以下类型的数值:
在本规范的语言中,使用下标后缀来区分不同数值种类的数值。下标 𝔽 指的是数字,下标 ℤ 指的是
BigInts。没有下标后缀的数值指的是
通常,当本规范引用一个数值时,例如在短语“y 的长度”或“由四个十六进制数字表示的
当本规范中使用术语整数时,它指的是一个
诸如 +、×、= 和 ≥ 之类的数值运算符指的是由操作数类型决定的那些运算。当应用于
数学函数
数学函数
符号“
短语“将 x 限制在 lower 和 upper
之间”的结果(其中 x 是一个
数学函数
数学函数
数学函数
从下界 a 到上界 b 的区间是一个可能是无限的、可能是空的、相同数值类型的数值集合。每个界限将被描述为包含的或排除的,但不能两者都是。有四种区间,如下所示:
例如,从 1(包含)到 2(排除)的
在本规范中,Function.prototype.apply 或
let n = 42;)相区别。
在本规范中,规范值和
从本规范的角度来看,“是”用于比较两个值的相等性,如“如果 bool 是
从 ECMAScript 语言的角度来看,语言值使用
对于规范值,无规范同一性的值的示例包括但不限于:
对于所有
本规范中的算法操作的值都具有关联的类型。可能的值类型正是本条款中定义的那些类型。类型进一步分为
ECMAScript 语言类型对应于 ECMAScript 程序员使用 ECMAScript 语言直接操作的值。ECMAScript 语言类型包括 Undefined、Null、Boolean、String、Symbol、Number、BigInt 和 Object。 ECMAScript 语言值 是由 ECMAScript 语言类型表征的值。
Undefined 类型只有一个值,称为
Null 类型只有一个值,称为
Boolean 类型表示一个逻辑实体,具有两个值,称为
字符串类型是所有长度不超过 253 - 1 个元素的零个或多个 16
位无符号
不解释字符串内容的 ECMAScript 操作不应用任何进一步的语义。解释字符串值的操作将每个元素视为单个 UTF-16 代码单元。但是,ECMAScript
不限制这些代码单元的值或它们之间的关系,因此将字符串内容进一步解释为以 UTF-16 编码的 Unicode 码点序列的操作必须考虑到格式错误的子序列。此类操作对数值在
函数 String.prototype.normalize(参见 String.prototype.localeCompare(参见
这种设计背后的基本原理是使字符串的实现尽可能简单和高性能。如果
在本规范中,短语“A、B、... 的字符串连接”(其中每个参数都是字符串值、代码单元或代码单元序列)表示其代码单元序列是每个参数(按顺序)的代码单元(按顺序)连接而成的字符串值。
短语“S 从 inclusiveStart 到 exclusiveEnd 的子字符串”(其中 S 是字符串值或代码单元序列,inclusiveStart 和
exclusiveEnd 是
短语“ASCII 词字符”表示以下字符串值,该值仅由 Unicode
基本拉丁块中的所有字母和数字以及 U+005F (LOW LINE) 组成:
由于历史原因,它对各种算法具有重要意义。
抽象操作 StringIndexOf 接受参数 string (一个字符串)、searchValue (一个字符串) 和
fromIndex (一个非负
如果 searchValue 是空字符串且 fromIndex ≤ string 的长度,则此算法返回 fromIndex。空字符串实际上在字符串中的每个位置都能找到,包括最后一个代码单元之后。
如果 fromIndex + searchValue 的长度 > string 的长度,则此算法始终返回
抽象操作 StringLastIndexOf 接受参数 string (一个字符串)、searchValue (一个字符串) 和
fromIndex (一个非负
如果 searchValue 是空字符串,则此算法返回 fromIndex。空字符串实际上在字符串中的每个位置都能找到,包括最后一个代码单元之后。
Symbol 类型是所有可用作对象属性键(
每个可能的 Symbol 值都是唯一且不可变的。
每个 Symbol 值都不可变地持有一个关联值,称为 [[Description]],该值要么是
知名符号是本规范算法明确引用的内置 Symbol 值。它们通常用作属性的键,这些属性的值充当规范算法的扩展点。除非另有规定,否则知名符号值由所有
在本规范中,使用标准的
%Symbol.name%。特别是,使用了以下名称:@@asyncIterator、@@hasInstance、@@isConcatSpreadable、@@| 规范名称 | [[Description]] | 值和用途 |
|---|---|---|
| %Symbol.asyncIterator% |
|
一个返回对象默认for-await-of 语句的语义调用。
|
| %Symbol.hasInstance% |
|
一个确定instanceof 运算符的语义调用。
|
| %Symbol.isConcatSpreadable% |
|
一个布尔值属性,如果为 true,则表示一个对象应由 Array.prototype.concat |
| %Symbol.iterator% |
|
一个返回对象默认 |
| %Symbol.match% |
|
一个正则表达式方法,用于将正则表达式与字符串进行匹配。由 String.prototype.match |
| %Symbol.matchAll% |
|
一个正则表达式方法,返回一个String.prototype.matchAll |
| %Symbol.replace% |
|
一个正则表达式方法,用于替换字符串中匹配的子字符串。由 String.prototype.replace |
| %Symbol.search% |
|
一个正则表达式方法,返回字符串中与正则表达式匹配的索引。由 String.prototype.search |
| %Symbol.species% |
|
一个函数值属性,是用于创建派生对象的 |
| %Symbol.split% |
|
一个正则表达式方法,用于在与正则表达式匹配的索引处拆分字符串。由 String.prototype.split |
| %Symbol.toPrimitive% |
|
一个将对象转换为相应原始值的方法。由 |
| %Symbol.toStringTag% |
|
一个字符串值属性,用于创建对象的默认字符串描述。由内置方法 Object.prototype.toString |
| %Symbol.unscopables% |
|
一个对象值属性,其自身和继承的属性名称是从关联对象的 with 环境绑定中排除的属性名称。
|
ECMAScript 有两种内置的数字类型:Number 和 BigInt。以下
由于数字类型通常无法在不损失精度或截断的情况下进行转换,因此 ECMAScript 语言不提供这些类型之间的隐式转换。在调用需要另一种类型的函数时,程序员必须显式调用
Number 和 BigInt 函数在类型之间进行转换。
ECMAScript 的第一版及后续版本为某些运算符提供了可能损失精度或
Number 类型恰好有
18,437,736,874,454,810,627 (即 NaN 产生。)在某些实现中,外部代码可能能够检测到各种 NaN
值之间的差异,但这种行为是
还有另外两个特殊值,称为+Infinity (或简称 Infinity) 和 -Infinity 产生。)
其余 18,437,736,874,454,810,624 (即
注意,既有+0 (或简称 0) 和 -0 产生。)
18,437,736,874,454,810,622 (即
其中 18,428,729,675,200,069,632 (即
其中 s 是 1 或 -1,m 是
其余 9,007,199,254,740,990 (即
其中 s 是 1 或 -1,m 是
注意,所有大小不超过 253 的正负
如果一个
在本规范中,短语“x 的Number 值”(其中 x 表示一个精确的实数数学量,甚至可能是一个无理数,如
π)指的是按以下方式选择的 Number 值。考虑 Number 类型的所有
+∞ 的
某些 ECMAScript 运算符仅处理特定范围内的
抽象操作 Number::unaryMinus 接受参数 x (一个 Number) 并返回一个 Number。调用时它执行以下步骤:
抽象操作 Number::bitwiseNOT 接受参数 x (一个 Number) 并返回一个
抽象操作 Number::exponentiate 接受参数 base (一个 Number) 和 exponent (一个
Number) 并返回一个 Number。它返回一个
当 base 是 ** exponent
的结果与
抽象操作 Number::multiply 接受参数 x (一个 Number) 和 y (一个 Number) 并返回一个
Number。它根据
抽象操作 Number::divide 接受参数 x (一个 Number) 和 y (一个 Number) 并返回一个
Number。它根据
抽象操作 Number::remainder 接受参数 n (一个 Number) 和 d (一个 Number) 并返回一个 Number。它产生其操作数隐式除法的余数,其中 n 是被除数,d 是除数。调用时它执行以下步骤:
在 C 和 C++ 中,余数运算符仅接受整数操作数;在 ECMAScript 中,它也接受浮点操作数。
% 运算符计算的浮点余数运算的结果与 % 在浮点运算上的行为类似于 Java 抽象操作 Number::add 接受参数 x (一个 Number) 和 y (一个 Number) 并返回一个
Number。它根据
抽象操作 Number::subtract 接受参数 x (一个 Number) 和 y (一个 Number) 并返回一个 Number。它执行减法,产生其操作数的差;x 是被减数,y 是减数。调用时它执行以下步骤:
x - y 总是产生与 x + (-y) 相同的结果。
抽象操作 Number::leftShift 接受参数 x (一个 Number) 和 y (一个 Number)
并返回一个
抽象操作 Number::signedRightShift 接受参数 x (一个 Number) 和 y (一个 Number)
并返回一个
抽象操作 Number::unsignedRightShift 接受参数 x (一个 Number) 和 y (一个 Number)
并返回一个
抽象操作 Number::lessThan 接受参数 x (一个 Number) 和 y (一个 Number) 并返回一个
Boolean 或
抽象操作 Number::equal 接受参数 x (一个 Number) 和 y (一个 Number) 并返回一个 Boolean。调用时它执行以下步骤:
抽象操作 Number::sameValue 接受参数 x (一个 Number) 和 y (一个 Number) 并返回一个 Boolean。调用时它执行以下步骤:
抽象操作 Number::sameValueZero 接受参数 x (一个 Number) 和 y (一个 Number) 并返回一个 Boolean。调用时它执行以下步骤:
抽象操作 NumberBitwiseOp 接受参数 op (&、^ 或
|)、x (一个 Number) 和 y (一个 Number) 并返回一个
&,则^,则|。
抽象操作 Number::bitwiseAND 接受参数 x (一个 Number) 和 y (一个 Number)
并返回一个
&,
x, y)。
抽象操作 Number::bitwiseXOR 接受参数 x (一个 Number) 和 y (一个 Number)
并返回一个
^,
x, y)。
抽象操作 Number::bitwiseOR 接受参数 x (一个 Number) 和 y (一个 Number)
并返回一个
|,
x, y)。
抽象操作 Number::toString 接受参数 x (一个 Number) 和 radix (一个
1.2e+3。ECMAScript 的实现者可能会发现 David M. Gay 编写的用于浮点数二进制到十进制转换的论文和代码很有用:
Gay, David M. Correctly Rounded Binary-Decimal and Decimal-Binary Conversions.
Numerical Analysis, Manuscript 90-10. AT&T Bell Laboratories (Murray Hill,
New Jersey). 1990年11月30日。可从以下网址获取:
https://ampl.com/_archive/first-website/REFS/rounding.pdf。
相关代码可从以下网址获取:
http://netlib.sandia.gov/fp/dtoa.c
和
http://netlib.sandia.gov/fp/g_fmt.c
也可以在各种 netlib 镜像站点找到。
BigInt 类型表示一个
抽象操作 BigInt::unaryMinus 接受参数 x(一个 BigInt)并返回一个 BigInt。调用时执行以下步骤:
抽象操作 BigInt::bitwiseNOT 接受参数 x(一个 BigInt)并返回一个 BigInt。它返回 x 的一的补码。调用时执行以下步骤:
抽象操作 BigInt::exponentiate 接受参数 base(一个 BigInt)和 exponent(一个
BigInt),返回
抽象操作 BigInt::multiply 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个 BigInt。调用时执行以下步骤:
抽象操作 BigInt::divide 接受参数 x(一个 BigInt)和 y(一个 BigInt),返回
抽象操作 BigInt::remainder 接受参数 n(一个 BigInt)和 d(一个 BigInt),返回
抽象操作 BigInt::add 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个 BigInt。调用时执行以下步骤:
抽象操作 BigInt::subtract 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个 BigInt。调用时执行以下步骤:
抽象操作 BigInt::leftShift 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个 BigInt。调用时执行以下步骤:
抽象操作 BigInt::signedRightShift 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个 BigInt。调用时执行以下步骤:
抽象操作 BigInt::unsignedRightShift 接受参数 x(一个 BigInt)和 y(一个
BigInt)并返回
抽象操作 BigInt::lessThan 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个布尔值。调用时执行以下步骤:
抽象操作 BigInt::equal 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个布尔值。调用时执行以下步骤:
抽象操作 BinaryAnd 接受参数 x(0 或 1)和 y(0 或 1)并返回 0 或 1。调用时执行以下步骤:
抽象操作 BinaryOr 接受参数 x(0 或 1)和 y(0 或 1)并返回 0 或 1。调用时执行以下步骤:
抽象操作 BinaryXor 接受参数 x(0 或 1)和 y(0 或 1)并返回 0 或 1。调用时执行以下步骤:
抽象操作 BigIntBitwiseOp 接受参数 op(&、^ 或
|)、x(一个 BigInt)和 y(一个 BigInt)并返回一个 BigInt。调用时执行以下步骤:
&,则
|,则
抽象操作 BigInt::bitwiseAND 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个 BigInt。调用时执行以下步骤:
&,
x, y)。
抽象操作 BigInt::bitwiseXOR 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个 BigInt。调用时执行以下步骤:
^,
x, y)。
抽象操作 BigInt::bitwiseOR 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个 BigInt。调用时执行以下步骤:
|,
x, y)。
抽象操作 BigInt::toString 接受参数 x(一个 BigInt)和 radix(一个在 2 到 36
的
Object 类型的每个实例,也简称为"一个 Object",表示属性的集合。每个属性要么是数据属性,要么是访问器属性:
对象的属性使用
整数索引是
所有对象在逻辑上都是属性的集合,但存在多种形式的对象,它们在访问和操作属性的语义上有所不同。请参见
此外,某些对象是可调用的;这些被称为函数或
本规范使用特性来定义和解释 Object 属性的状态,如
| 特性名称 | 存在该特性的属性类型 | 值域 | 默认值 | 描述 |
|---|---|---|---|---|
| [[Value]] | 通过对属性的 get 访问检索到的值。 | |||
| [[Writable]] | 布尔值 | 如果为 |
||
| [[Get]] | Object 或 |
如果值 |
||
| [[Set]] | Object 或 |
如果值 |
||
| [[Enumerable]] | 布尔值 | 如果为 |
||
| [[Configurable]] | 布尔值 | 如果为 |
在 ECMAScript 中,对象的实际语义通过称为内部方法的算法指定。ECMAScript 引擎中的每个对象都与一组定义其运行时行为的内部方法相关联。这些内部方法不是 ECMAScript 语言的一部分。它们由本规范纯粹为了解释目的而定义。但是,ECMAScript 实现中的每个对象都必须按照与其关联的内部方法所指定的方式行为。实现这一点的确切方式由实现决定。
内部方法名称是多态的。这意味着当在不同的对象值上调用相同的内部方法名称时,可能执行不同的算法。实际调用内部方法的对象是调用的"目标"。如果在运行时,算法的实现尝试使用对象不支持的内部方法,则抛出
内部槽对应于与对象关联并由各种 ECMAScript 规范算法使用的内部状态。内部槽不是对象属性,它们不被继承。根据特定的内部槽规范,这种状态可能由任何
所有对象都有一个名为 [[PrivateElements]] 的内部槽,它是
内部方法和内部槽在本规范中使用双方括号 [[ ]] 括起来的名称标识。
普通对象是满足以下所有条件的对象:
异质对象是不是
本规范通过对象的内部方法识别不同种类的
除了参数之外,内部方法始终可以访问作为方法调用目标的对象。
内部方法隐式返回
| 内部方法 | 签名 | 描述 |
|---|---|---|
| [[GetPrototypeOf]] | ( ) → Object | Null | 确定为此对象提供继承属性的对象。 |
| [[SetPrototypeOf]] | (Object | Null) → Boolean | 将此对象与提供继承属性的另一个对象关联。传递 |
| [[IsExtensible]] | ( ) → Boolean | 确定是否允许向此对象添加额外属性。 |
| [[PreventExtensions]] | ( ) → Boolean | 控制是否可以向此对象添加新属性。如果操作成功则返回 |
| [[GetOwnProperty]] | (propertyKey) → Undefined | |
返回此对象键为 propertyKey 的自有属性的 |
| [[DefineOwnProperty]] | (propertyKey, PropertyDescriptor) → Boolean | 创建或更改键为 propertyKey 的自有属性,使其具有 PropertyDescriptor
描述的状态。如果该属性成功创建/更新则返回 |
| [[HasProperty]] | (propertyKey) → Boolean | 返回布尔值,表示此对象是否已经具有键为 propertyKey 的自有或继承属性。 |
| [[Get]] | (propertyKey, Receiver) → any | 从此对象返回键为 propertyKey 的属性值。如果必须执行任何 ECMAScript
代码来检索属性值,Receiver 用作评估代码时的 |
| [[Set]] | (propertyKey, value, Receiver) → Boolean | 将键为 propertyKey 的属性值设置为 value。如果必须执行任何 ECMAScript
代码来设置属性值,Receiver 用作评估代码时的 |
| [[Delete]] | (propertyKey) → Boolean | 从此对象中删除键为 propertyKey 的自有属性。如果属性未被删除且仍然存在则返回
|
| [[OwnPropertyKeys]] | ( ) → |
返回一个 |
| 内部方法 | 签名 | 描述 |
|---|---|---|
| [[Call]] | (any, a |
执行与此对象关联的代码。通过函数调用表达式调用。内部方法的参数是 |
| [[Construct]] | (a |
创建对象。通过 new 操作符或 super
调用调用。内部方法的第一个参数是一个super
调用的参数。第二个参数是最初应用 new 操作符的对象。实现此内部方法的对象称为 |
ECMAScript 引擎中对象的内部方法必须符合下面指定的不变式列表。本规范中的普通 ECMAScript 对象以及所有标准
任何实现提供的
实现不得允许以任何方式规避这些不变式,例如通过提供实现基本内部方法功能但不强制执行其不变式的替代接口。
任何内部方法返回的值必须是一个
内部方法不得返回
作为第三个不变式的结果,如果属性被描述为
知名内置对象是被本规范算法明确引用的内置对象,通常具有
在本规范中,像 %name% 这样的引用意味着与当前
规范类型对应于在算法中用于描述 ECMAScript 语言构造和
枚举是规范内部的值,不能从 ECMAScript
代码直接观察到。枚举使用
列表类型用于解释 new
表达式、函数调用和其他需要简单有序值列表的算法中参数列表的求值(参见
当算法遍历列表的元素而不指定顺序时,使用的顺序是列表中元素的顺序。
为了在本规范中方便表示,可以使用字面量语法来表达新的列表值。例如,« 1, 2 » 定义了一个有两个元素的列表值,每个元素都初始化为特定值。新的空列表可以表示为 « »。
在本规范中,短语"A、B、... 的列表连接"(其中每个参数都是可能为空的列表)表示一个新的列表值,其元素是每个参数的元素(按顺序)的连接(按顺序)。
当应用于字符串列表时,短语"按字典序码元顺序排序"意味着按每个码元的数值排序,直到较短字符串的长度,如果所有都相等,则较短的字符串排在较长的字符串之前,如抽象操作
记录类型用于描述本规范算法中的数据聚合。记录类型值由一个或多个命名字段组成。每个字段的值是
为了在本规范中方便表示,可以使用类似对象字面量的语法来表达记录值。例如,{ [[Field1]]: 42, [[Field2]]:
在规范文本和算法中,可以使用点记法来引用记录值的特定字段。例如,如果 R 是前一段中显示的记录,那么 R.[[Field2]] 是"R 中名为 [[Field2]] 的字段"的简写。
常用记录字段组合的模式可以被命名,该名称可以用作字面量记录值的前缀,以标识所描述的特定类型的聚合。例如:PropertyDescriptor { [[Value]]: 42, [[Writable]]:
集合类型用于解释在
关系类型用于解释对集合的约束。关系类型的值是其值域中值的有序对的集合。例如,事件上的关系是事件有序对的集合。对于关系 R 和 R 值域中的两个值 a 和 b,a R b 是说有序对 (a, b) 是 R 的成员的简写。关系是相对于某些条件的最小关系,当它是满足这些条件的最小关系时。
严格偏序是满足以下条件的关系值 R。
对于 R 域中的所有 a、b 和 c:
上述两个性质分别称为非反射性和传递性。
严格全序是满足以下条件的关系值 R。
对于 R 域中的所有 a、b 和 c:
上述三个性质分别称为完全性、非反射性和传递性。
完成记录规范类型用于解释值和控制流的运行时传播,例如执行非本地控制转移的语句(break、continue、return
和 throw)的行为。
完成记录具有
以下简写术语有时用于指代完成记录。
本规范中定义的可调用对象只返回正常完成或 throw 完成。返回任何其他类型的完成记录被认为是编辑错误。
抽象操作 NormalCompletion 接受参数 value(除
抽象操作 ThrowCompletion 接受参数 value(一个
抽象操作 ReturnCompletion 接受参数 value(一个
抽象操作 UpdateEmpty 接受参数 completionRecord(一个
引用记录类型用于解释诸如
delete、typeof、赋值运算符、super
引用记录是一个已解析的名称或(可能尚未解析的)属性绑定;其字段由
| 字段名 | 值 | 含义 |
|---|---|---|
| [[Base]] | 一个 |
持有绑定的值或 |
| [[ReferencedName]] | 一个 |
绑定的名称。如果 [[Base]] 值是 |
| [[Strict]] | 一个布尔值 | 如果 |
| [[ThisValue]] | 一个 |
如果不是 super |
本规范中使用以下
抽象操作 IsPropertyReference 接受参数 V(一个
抽象操作 IsUnresolvableReference 接受参数 V(一个
抽象操作 IsSuperReference 接受参数 V(一个
抽象操作 IsPrivateReference 接受参数 V(一个
抽象操作 GetValue 接受参数 V(一个
抽象操作 PutValue 接受参数 V(一个
抽象操作 GetThisValue 接受参数 V(一个
抽象操作 InitializeReferencedBinding 接受参数 V(一个
抽象操作 MakePrivateReference 接受参数 baseValue(一个
属性描述符类型用于解释对象属性特性的操作和具体化。属性描述符是一个具有零个或多个字段的
属性描述符值可以根据某些字段的存在或使用进一步分类为数据属性描述符和访问器属性描述符。数据属性描述符是包含名为 [[Value]] 或 [[Writable]] 的任何字段的描述符。访问器属性描述符是包含名为 [[Get]] 或
[[Set]] 的任何字段的描述符。任何属性描述符都可以有名为 [[Enumerable]]
和 [[Configurable]]
的字段。属性描述符值不能既是数据属性描述符又是访问器属性描述符;但是,它可以两者都不是(在这种情况下它是通用属性描述符)。完全填充的属性描述符是访问器属性描述符或数据属性描述符,并且具有
本规范中使用以下
抽象操作 IsAccessorDescriptor 接受参数 Desc(一个
抽象操作 IsDataDescriptor 接受参数 Desc(一个
抽象操作 IsGenericDescriptor 接受参数 Desc(一个
抽象操作 FromPropertyDescriptor 接受参数 Desc(一个
抽象操作 ToPropertyDescriptor 接受参数 Obj(一个
抽象操作 CompletePropertyDescriptor 接受参数 Desc(一个
抽象闭包规范类型用于引用算法步骤以及一系列值。抽象闭包是元值,使用函数调用样式调用,例如
closure(arg1, arg2)。与
在创建抽象闭包的算法步骤中,值使用动词"capture"后跟别名列表来捕获。当创建抽象闭包时,它捕获当时与每个别名关联的值。在指定调用抽象闭包时要执行的算法的步骤中,每个捕获的值都通过用于捕获该值的别名来引用。
如果抽象闭包返回
抽象闭包作为其他算法的一部分内联创建,如以下示例所示。
数据块规范类型用于描述一个不同且可变的字节大小(8位)数值序列。字节值是
为了在本规范中表示方便,可以使用类似数组的语法来访问数据块值的各个字节。此表示法将数据块值表示为基于 0 的
驻留在内存中且可以被多个
共享数据块的语义通过
本规范中使用以下
抽象操作 CreateByteDataBlock 接受参数 size(一个非负
抽象操作 CreateSharedByteDataBlock 接受参数 size(一个非负
抽象操作 CopyDataBlockBytes 接受参数 toBlock(一个
PrivateElement 类型是一个
PrivateElement 类型的值是
| 字段名 | 出现该字段的 [[Kind]] 字段值 | 值 | 含义 |
|---|---|---|---|
| [[Key]] | 全部 | 一个 |
字段、方法或访问器的名称。 |
| [[Kind]] | 全部 | 元素的类型。 | |
| [[Value]] | 一个 |
字段的值。 | |
| [[Get]] | 一个 |
私有访问器的 getter。 | |
| [[Set]] | 一个 |
私有访问器的 setter。 |
ClassFieldDefinition 类型是一个
ClassFieldDefinition 类型的值是
| 字段名 | 值 | 含义 |
|---|---|---|
| [[Name]] | 一个 |
字段的名称。 |
| [[Initializer]] | 一个 ECMAScript |
字段的初始化器(如果有)。 |
私有名称规范类型用于描述一个全局唯一值(即使与其他私有名称在其他方面无法区分,该值也与任何其他私有名称不同),它表示私有类元素(字段、方法或访问器)的键。每个私有名称都有一个关联的不可变
[[Description]],它
ClassStaticBlockDefinition
记录是一个
ClassStaticBlockDefinition 记录具有
| 字段名 | 值 | 含义 |
|---|---|---|
| [[BodyFunction]] | 一个 ECMAScript |
在类的静态初始化期间要调用的 |
这些操作不是 ECMAScript 语言的一部分;定义它们仅是为了帮助说明 ECMAScript 语言的语义。其他更专门的
ECMAScript 语言根据需要隐式执行自动类型转换。为了阐明某些构造的语义,定义一组转换
抽象操作 ToPrimitive 接受参数 input(一个
当调用 ToPrimitive 时不带提示,那么它通常表现为提示是
抽象操作 OrdinaryToPrimitive 接受参数 O(一个对象)和
hint(
抽象操作 ToBoolean 接受参数 argument(一个
抽象操作 ToNumeric 接受参数 value(一个
抽象操作 ToNumber 接受参数 argument(一个
抽象操作
所有未在上面明确定义的语法符号都具有数字字面量词法语法中使用的定义(
应注意
0 数字。+ 或 - 来表示其符号。
Infinity 和 -Infinity 被识别为 抽象操作 StringToNumber 接受参数 str(一个字符串)并返回一个数字。它在被调用时执行以下步骤:
它在以下产生式上分段定义:
抽象操作 RoundMVResult 接受参数 n(一个
抽象操作 ToIntegerOrInfinity 接受参数 argument(一个
抽象操作 ToInt32 接受参数 argument(一个
根据 ToInt32 的上述定义:
抽象操作 ToUint32 接受参数 argument(一个
抽象操作 ToInt16 接受参数 argument(一个
抽象操作 ToUint16 接受参数 argument(一个
抽象操作 ToInt8 接受参数 argument(一个
抽象操作 ToUint8 接受参数 argument(一个
抽象操作 ToUint8Clamp 接受参数 argument(一个
与大多数其他 ECMAScript Math.round
抽象操作 ToBigInt 接受参数 argument(一个
| 参数类型 | 结果 |
|---|---|
| Undefined | 抛出 |
| Null | 抛出 |
| Boolean | 如果 prim 是 1n,如果
prim 是 0n。
|
| BigInt | 返回 prim。 |
| Number | 抛出 |
| String |
|
| Symbol | 抛出 |
抽象操作 StringToBigInt 接受参数 str(一个字符串)并返回一个 BigInt 或
抽象操作 ToBigInt64 接受参数 argument(一个
抽象操作 ToBigUint64 接受参数 argument(一个
抽象操作 ToString 接受参数 argument(一个
抽象操作 ToObject 接受参数 argument(一个
| 参数类型 | 结果 |
|---|---|
| Undefined | 抛出 |
| Null | 抛出 |
| Boolean | 返回一个新的布尔对象,其 [[BooleanData]] 内部槽设置为
argument。有关布尔对象的描述,请参见 |
| Number | 返回一个新的数字对象,其 [[NumberData]] 内部槽设置为
argument。有关数字对象的描述,请参见 |
| String | 返回一个新的字符串对象,其 [[StringData]] 内部槽设置为
argument。有关字符串对象的描述,请参见 |
| Symbol | 返回一个新的符号对象,其 [[SymbolData]] 内部槽设置为
argument。有关符号对象的描述,请参见 |
| BigInt | 返回一个新的 BigInt 对象,其 [[BigIntData]] 内部槽设置为
argument。有关 BigInt 对象的描述,请参见 |
| Object | 返回 argument。 |
抽象操作 ToPropertyKey 接受参数 argument(一个
抽象操作 ToLength 接受参数 argument(一个
抽象操作 CanonicalNumericIndexString 接受参数 argument(一个字符串)并返回一个数字或
规范数字字符串是 CanonicalNumericIndexString 抽象操作不返回
抽象操作 ToIndex 接受参数 value(一个
抽象操作 RequireObjectCoercible 接受参数 argument(一个
| 参数类型 | 结果 |
|---|---|
| Undefined | 抛出 |
| Null | 抛出 |
| Boolean | 返回 argument。 |
| Number | 返回 argument。 |
| String | 返回 argument。 |
| Symbol | 返回 argument。 |
| BigInt | 返回 argument。 |
| Object | 返回 argument。 |
抽象操作 IsArray 接受参数 argument(一个
抽象操作 IsCallable 接受参数 argument(一个
抽象操作 IsConstructor 接受参数 argument(一个
抽象操作 IsExtensible 接受参数 O(一个对象)并返回一个
抽象操作 IsRegExp 接受参数 argument(一个
抽象操作 IsStringWellFormedUnicode 接受参数 string(一个字符串)并返回一个布尔值。它将 string 解释为
UTF-16 编码代码点的序列,如
抽象操作 SameType 接受参数 x(一个
抽象操作 SameValue 接受参数 x(一个
此算法与
抽象操作 SameValueZero 接受参数 x(一个
SameValueZero 与
抽象操作 SameValueNonNumber 接受参数 x(一个
抽象操作 IsLessThan 接受参数 x(一个
字符串的比较使用 UTF-16 代码单元值序列的简单字典序。没有尝试使用 Unicode 规范中定义的更复杂的、面向语义的字符或字符串相等性和整理顺序定义。因此,根据
Unicode 标准规范相等但不在相同规范化形式中的字符串值可能测试为不相等。还要注意,对于包含
抽象操作 IsLooselyEqual 接受参数 x(一个== 运算符提供语义。它在被调用时执行以下步骤:
抽象操作 IsStrictlyEqual 接受参数 x(一个=== 运算符提供语义。它在被调用时执行以下步骤:
此算法与
抽象操作 MakeBasicObject 接受参数 internalSlotsList(一个内部槽名称的
在本规范中,
抽象操作 Get 接受参数 O(一个对象)和 P(一个
抽象操作 GetV 接受参数 V(一个
抽象操作 Set 接受参数 O(一个对象)、P(一个
抽象操作 CreateDataProperty 接受参数 O(一个对象)、P(一个
此抽象操作创建一个属性,其特性设置为与 ECMAScript 语言赋值运算符创建的属性相同的默认值。通常,该属性还不存在。如果它存在且不可配置,或者如果 O
不可扩展,[[DefineOwnProperty]] 将返回
抽象操作 CreateDataPropertyOrThrow 接受参数 O(一个对象)、P(一个
此抽象操作创建一个属性,其特性设置为与 ECMAScript 语言赋值运算符创建的属性相同的默认值。通常,该属性还不存在。如果它存在且不可配置,或者如果 O
不可扩展,[[DefineOwnProperty]] 将返回
抽象操作 CreateNonEnumerableDataPropertyOrThrow 接受参数 O(一个对象)、P(一个
此抽象操作创建一个属性,其特性设置为与 ECMAScript 语言赋值运算符创建的属性相同的默认值,但它不可枚举。通常,该属性还不存在。如果它存在,
抽象操作 DefinePropertyOrThrow 接受参数 O(一个对象)、P(一个
抽象操作 DeletePropertyOrThrow 接受参数 O(一个对象)和 P(一个
抽象操作 GetMethod 接受参数 V(一个
抽象操作 HasProperty 接受参数 O(一个对象)和 P(一个
抽象操作 HasOwnProperty 接受参数 O(一个对象)和 P(一个
抽象操作 Call 接受参数 F(一个
抽象操作 Construct 接受参数 F(一个
如果 newTarget 不存在,此操作等价于:new F(...argumentsList)
抽象操作 SetIntegrityLevel 接受参数 O(一个对象)和 level(
抽象操作 TestIntegrityLevel 接受参数 O(一个对象)和 level(
抽象操作 CreateArrayFromList 接受参数 elements(一个
抽象操作 LengthOfArrayLike 接受参数 obj(一个对象)并返回一个
类数组对象是此操作返回
抽象操作 CreateListFromArrayLike 接受参数 obj(一个
抽象操作 Invoke 接受参数 V(一个
抽象操作 OrdinaryHasInstance 接受参数 C(一个
抽象操作 SpeciesConstructor 接受参数 O(一个对象)和 defaultConstructor(一个
抽象操作 EnumerableOwnProperties 接受参数 O(一个对象)和
kind(
抽象操作 GetFunctionRealm 接受参数 obj(一个
抽象操作 CopyDataProperties 接受参数 target(一个对象)、source(一个
这里传入的目标总是一个新创建的对象,在抛出错误的情况下不能直接访问。
抽象操作 PrivateElementFind 接受参数 O(一个对象)和 P(一个
抽象操作 PrivateFieldAdd 接受参数 O(一个对象)、P(一个
抽象操作 PrivateMethodOrAccessorAdd 接受参数 O(一个对象)和 method(一个
私有方法和访问器的值在实例之间共享。此操作不会创建方法或访问器的新副本。
HostEnsureCanAddPrivateElement 的实现必须符合以下要求:
HostEnsureCanAddPrivateElement 的默认实现是返回
此抽象操作仅由作为 Web 浏览器的 ECMAScript
抽象操作 PrivateGet 接受参数 O(一个对象)和 P(一个
抽象操作 PrivateSet 接受参数 O(一个对象)、P(一个
抽象操作 DefineField 接受参数 receiver(一个对象)和 fieldRecord(一个
抽象操作 InitializeInstanceElements 接受参数 O(一个对象)和 constructor(一个 ECMAScript
抽象操作 AddValueToKeyedGroup 接受参数 groups(一个
抽象操作 GroupBy 接受参数 items(一个
抽象操作 SetterThatIgnoresPrototypeProperties 接受参数 thisValue(一个
参见通用迭代接口(
迭代器记录是一个next 方法。
迭代器记录具有
| 字段名称 | 值 | 含义 |
|---|---|---|
| [[Iterator]] | 一个对象 | 符合 |
| [[NextMethod]] | 一个 |
[[Iterator]] 对象的 next 方法。 |
| [[Done]] | 一个布尔值 |
抽象操作 GetIteratorDirect 接受参数 obj(一个对象)并返回一个
抽象操作 GetIteratorFromMethod 接受参数 obj(一个
抽象操作 GetIterator 接受参数 obj(一个
抽象操作 GetIteratorFlattenable 接受参数 obj(一个
抽象操作 IteratorNext 接受参数 iteratorRecord(一个
抽象操作 IteratorComplete 接受参数 iteratorResult(一个对象)并返回一个
抽象操作 IteratorValue 接受参数 iteratorResult(一个对象)并返回一个
抽象操作 IteratorStep 接受参数 iteratorRecord(一个
抽象操作 IteratorStepValue 接受参数 iteratorRecord(一个
抽象操作 IteratorClose 接受参数 iteratorRecord(一个
IfAbruptCloseIterator 是使用
与以下含义相同:
抽象操作 AsyncIteratorClose 接受参数 iteratorRecord(一个
抽象操作 CreateIteratorResultObject 接受参数 value(一个
抽象操作 CreateListIteratorRecord 接受参数 list(一个包含
列表
抽象操作 IteratorToList 接受参数 iteratorRecord(一个
除了本节中定义的操作外,专用的
它在以下产生式上分段定义:
没有必要将 export default
在
export 在
本节由附录
export 本节由附录
export 在函数或脚本的顶层,函数声明被当作 var 声明处理,而不是词法声明。
在函数或脚本的顶层,内部函数声明被当作 var 声明处理。
此部分由附录
本节由附录
本节由附录
抽象操作 IsAnonymousFunctionDefinition 接受参数 expr(一个
本规范中所有未在下面列出的语法产生式备选都隐式具有以下 包含 (Contains) 的默认定义:
依赖于子结构的静态语义规则通常不深入函数定义。
依赖于子结构的静态语义规则通常不深入类体,除了
依赖于子结构的静态语义规则通常不深入 static 初始化块。
super 或
this 之一,返回 super 或
this 之一,返回 super,返回
这些操作在规范中的多个地方使用。
它在以下产生式上分段定义:
抽象操作 InitializeBoundName 接受参数 name(一个字符串)、value(一个
它在以下产生式上分段定义:
环境记录是一种规范类型,
用于定义
每个环境记录都有一个[[OuterEnv]]字段,它要么是
环境记录纯粹是规范机制,不需要对应于ECMAScript实现的任何特定构件。 ECMAScript程序不可能直接访问或操作这样的值。
| 方法 | 目的 |
|---|---|
| HasBinding(N) |
确定 |
| CreateMutableBinding(N, D) |
在 |
| CreateImmutableBinding(N, S) |
在 |
| InitializeBinding(N, V) |
设置 |
| SetMutableBinding(N, V, S) |
设置 |
| GetBindingValue(N, S) |
从 |
| DeleteBinding(N) |
从 |
| HasThisBinding() |
确定this绑定。如果建立则返回 |
| HasSuperBinding() |
确定super方法绑定。如果建立则返回
|
| WithBaseObject() |
如果此with语句关联,则返回with对象。
否则,返回 |
每个声明式环境记录都与包含变量、常量、let、类、模块、导入和/或函数声明的ECMAScript程序作用域相关联。声明式环境记录绑定其作用域内包含的声明所定义的标识符集合。
导致步骤
function f() { eval("var x; x = (delete x, 0);"); }
每个对象环境记录
都与一个称为其绑定对象的对象相关联。对象环境记录绑定一组字符串标识符名称,
这些名称直接对应于其绑定对象的属性名称。不是
为with语句(
对象环境记录具有
通常envRec不会有N的绑定,但如果有,
this绑定。
super绑定。
函数环境记录是一个this绑定。如果函数不是super,其函数环境记录还包含用于在函数内执行super方法调用的状态。
函数环境记录具有
| 字段名称 | 值 | 含义 |
|---|---|---|
| [[ThisValue]] |
一个 |
这是用于此函数调用的 |
| [[ThisBindingStatus]] |
|
如果值是 |
| [[FunctionObject]] |
一个ECMAScript |
调用导致创建此 |
| [[NewTarget]] |
一个 |
如果此 |
函数环境记录支持
抽象操作BindThisValue接受参数envRec(一个
抽象操作GetSuperBase接受参数envRec(一个super属性访问基础的对象。值
全局环境记录用于表示被在共同
全局环境记录在逻辑上是单个记录,但它被指定为一个封装
属性可以直接在
全局环境记录具有
this绑定。
super绑定。
抽象操作HasLexicalDeclaration接受参数envRec(一个
抽象操作HasRestrictedGlobalProperty接受参数envRec(一个
抽象操作CanDeclareGlobalVar接受参数envRec(一个
抽象操作CanDeclareGlobalFunction接受参数envRec(一个
抽象操作CreateGlobalVarBinding接受参数envRec(一个
抽象操作CreateGlobalFunctionBinding接受参数envRec(一个
模块环境记录是一个
模块环境记录支持
this 绑定。
抽象操作 CreateImportBinding 接收参数 envRec(一个
抽象操作 GetIdentifierReference 接收参数 env(一个
抽象操作 NewDeclarativeEnvironment 接收参数 E(一个
抽象操作 NewObjectEnvironment 接收参数 O(一个对象)、W(一个布尔值)和
E(一个
抽象操作 NewFunctionEnvironment 接收参数 F(一个 ECMAScript
抽象操作 NewGlobalEnvironment 接收参数 G(一个对象)和 thisValue(一个对象),并返回一个
抽象操作 NewModuleEnvironment 接收参数 E(一个
私有环境记录是一种规范机制,用于基于 ECMAScript 代码中
抽象操作 NewPrivateEnvironment 接收参数 outerPrivateEnv(一个
抽象操作 ResolvePrivateIdentifier 接收参数 privateEnv(一个
在求值之前,所有 ECMAScript 代码都必须与一个领域关联。从概念上讲,一个
| 字段名称 | 值 | 含义 |
|---|---|---|
| [[AgentSignifier]] |
一个 |
拥有此 |
| [[Intrinsics]] |
一个 |
与此 |
| [[GlobalObject]] | 一个对象 |
此 |
| [[GlobalEnv]] |
一个 |
此 |
| [[TemplateMap]] |
具有字段 [[Site]](一个 |
模板对象使用其 一旦
|
| [[LoadedModules]] |
|
从此
如
import() 表达式时使用。
|
| [[HostDefined]] |
任何值(默认值为 |
为需要将附加信息与 |
抽象操作 InitializeHostDefinedRealm 不接收参数,并返回
this 绑定返回除抽象操作 CreateIntrinsics 接收参数 realmRec(一个
抽象操作 SetDefaultGlobalBindings 接收参数 realmRec(一个
执行上下文是一种规范设备,用于跟踪 ECMAScript
实现对代码的运行时求值。在任何时候,每个
执行上下文栈用于跟踪执行上下文。
执行上下文包含跟踪其关联代码的执行进度所需的任何实现特定状态。每个执行上下文至少具有
ECMAScript 代码执行上下文具有
执行上下文的 LexicalEnvironment 和 VariableEnvironment 组件始终是
表示生成器求值的执行上下文具有
| 组件 | 目的 |
|---|---|
| Generator |
此 |
在大多数情况下,只有
执行上下文纯粹是一种规范机制,不需要对应 ECMAScript 实现的任何特定工件。ECMAScript 代码不可能直接访问或观察执行上下文。
抽象操作 GetActiveScriptOrModule 不接收参数,并返回
抽象操作 ResolveBinding 接收参数 name(一个字符串)和可选参数 env(一个
ResolveBinding 的结果始终是一个
抽象操作 GetThisEnvironment 不接收参数,并返回一个this
绑定的
步骤this 绑定的全局环境结束。
抽象操作 ResolveThisBinding 不接收参数,并返回this
的绑定。调用时执行以下步骤:
抽象操作 GetNewTarget 不接收参数,并返回一个对象或
抽象操作 GetGlobalObject 不接收参数,并返回一个对象。它返回当前
作业是一个无参数的
在任何特定时间,scriptOrModule(一个
在任何特定时间,如果所有以下条件都为真,则执行准备求值 ECMAScript 代码:
特定类型的
作业回调记录是用于存储
例如,WHATWG HTML 规范(https://html.spec.whatwg.org/)使用
作业回调记录具有
HostMakeJobCallback 的实现必须符合以下要求:
HostMakeJobCallback 的默认实现在调用时执行以下步骤:
非 Web 浏览器的 ECMAScript
这在回调被传递给负责其最终调度和运行的函数时调用。例如,promise.then(thenAction) 在调用
Promise.prototype.then 时对 thenAction 调用
MakeJobCallback,而不是在调度反应
HostCallJobCallback 的实现必须符合以下要求:
HostCallJobCallback 的默认实现在调用时执行以下步骤:
非 Web 浏览器的 ECMAScript
HostEnqueueGenericJob 的实现必须符合
HostEnqueuePromiseJob 的实现必须符合
HostEnqueueTimeoutJob 的实现必须符合
代理包含一组 ECMAScript
例如,一些 Web 浏览器在浏览器窗口的多个不相关选项卡之间共享单个
当
代理标识符是用于标识
| 字段名称 | 值 | 含义 |
|---|---|---|
| [[LittleEndian]] | 布尔值 | 当算法 |
| [[CanBlock]] | 布尔值 | 确定 |
| [[Signifier]] | 一个 |
在其 |
| [[IsLockFree1]] | 布尔值 | 如果对单字节值的原子操作是无锁的,则为 |
| [[IsLockFree2]] | 布尔值 | 如果对双字节值的原子操作是无锁的,则为 |
| [[IsLockFree8]] | 布尔值 | 如果对八字节值的原子操作是无锁的,则为 |
| [[CandidateExecution]] | 一个 |
参见 |
| [[KeptAlive]] | 对象或符号的 |
初始为一个新的空 |
| [[ModuleAsyncEvaluationCount]] | 一个 |
初始为 0,用于为异步或具有异步依赖的模块的[[AsyncEvaluationOrder]]字段分配唯一的递增值。 |
一旦[[Signifier]]、[[IsLockFree1]]和[[IsLockFree2]]的值被
[[IsLockFree1]]和[[IsLockFree2]]的值不一定由硬件决定,也可能反映可能随时间和 ECMAScript 实现而变化的实现选择。
没有[[IsLockFree4]]字段:4 字节原子操作总是无锁的。
实际上,如果原子操作是用任何类型的锁实现的,则该操作不是无锁的。无锁并不意味着无等待:对于完成无锁原子操作可能需要多少个机器步骤没有上限。
大小为n的原子访问是无锁的,并不意味着大小为n的非原子访问的(感知的)原子性,具体来说,非原子访问仍然可能作为几个单独的内存访问序列来执行。详见
抽象操作 AgentSignifier 不接收参数,并返回一个
抽象操作 AgentCanSuspend 不接收参数,并返回一个布尔值。调用时执行以下步骤:
在某些环境中,给定
抽象操作 IncrementModuleAsyncEvaluationCount 不接收参数,并返回一个
此值仅用于跟踪挂起模块之间的相对求值顺序。当没有挂起模块时,实现可以不可观察地将[[ModuleAsyncEvaluationCount]]重置为 0。
代理集群是可以通过操作共享内存进行通信的
每个
集群内的所有
如果代理集群内不同的
集群内的所有
集群内的所有
嵌入可以在
嵌入可以在
以下每个规范值以及从它们可传递到达的值都恰好属于一个代理集群。
在集群中任何
代理集群是一种规范机制,不需要对应 ECMAScript 实现的任何特定工件。
当
实现必须确保:
本规范不保证任何对象或符号会被垃圾回收。不
WeakRef.prototype.deref时,引用对象(如果未返回这两个动作(
一些 ECMAScript 实现包括在后台运行的垃圾收集器实现,包括当 ECMAScript 处于空闲状态时。让
对于某个对象和/或符号集合S,关于S的假设 WeakRef
无关执行是指这样的执行:其引用对象是S元素的
在求值期间的任何时点,如果满足以下任一条件,则对象和/或符号集合S被认为是活跃的:
对象或符号在字段、内部槽或属性中的存在并不意味着该值是活跃的。例如,如果所讨论的值从未传回程序,那么它就无法被观察到。
WeakMap 中的键、WeakSet 的成员以及
上述定义意味着,如果 WeakMap 中的键不是活跃的,那么其对应的值也不一定是活跃的。
在任何时候,如果对象和/或符号集合S不是
与活跃性定义一起,本条款规定了实现可以应用于
可以在不观察对象身份的情况下访问对象。诸如死变量消除和对身份未被观察的非逃逸对象属性的标量替换等优化是允许的。因此,这些优化被允许可观察地清空指向此类对象的
另一方面,如果对象的身份是可观察的,并且该对象在
因为调用
设cleanupJob为捕获finalizationRegistry的无参数新
HostEnqueueFinalizationRegistryCleanupJob
的实现调度cleanupJob在将来某个时间执行(如果可能)。它还必须符合
抽象操作 ClearKeptObjects 不接收参数,并返回
抽象操作 AddToKeptObjects 接收参数value(一个对象或符号),并返回
抽象操作 CleanupFinalizationRegistry 接收参数finalizationRegistry(一个
抽象操作 CanBeHeldWeakly 接收参数v(一个
没有
所有
每个
在以下算法描述中,假设O是一个
每个
抽象操作OrdinaryGetPrototypeOf接受参数O(一个Object),返回一个Object或
抽象操作OrdinarySetPrototypeOf接受参数O(一个Object)和V(一个Object或
抽象操作OrdinaryIsExtensible接受参数O(一个Object),返回一个Boolean。调用时执行以下步骤:
抽象操作OrdinaryPreventExtensions接受参数O(一个Object),返回
抽象操作OrdinaryGetOwnProperty接受参数O(一个Object)和P(一个
抽象操作OrdinaryDefineOwnProperty接受参数O(一个Object)、P(一个
抽象操作IsCompatiblePropertyDescriptor接受参数Extensible(一个Boolean)、Desc(一个
抽象操作ValidateAndApplyPropertyDescriptor接受参数O(一个Object或
抽象操作OrdinaryHasProperty接受参数O(一个Object)和P(一个
抽象操作OrdinaryGet接受参数O(一个Object)、P(一个
抽象操作OrdinarySet接受参数O(一个Object)、P(一个
抽象操作OrdinarySetWithOwnDescriptor接受参数O(一个Object)、P(一个
抽象操作OrdinaryDelete接受参数O(一个Object)和P(一个
抽象操作OrdinaryOwnPropertyKeys接受参数O(一个Object),返回一个
抽象操作OrdinaryObjectCreate接受参数proto(一个Object或
虽然OrdinaryObjectCreate除了调用
抽象操作OrdinaryCreateFromConstructor接受参数constructor(一个
抽象操作GetPrototypeFromConstructor接受参数constructor(一个
抽象操作RequireInternalSlot接受参数O(一个
ECMAScript
除了[[Extensible]]和[[Prototype]]之外,ECMAScript
| 内部插槽 | 类型 | 描述 |
|---|---|---|
| [[Environment]] |
一个 |
函数封闭的 |
| [[PrivateEnvironment]] |
一个 |
函数封闭的 |
| [[FormalParameters]] |
一个 |
定义函数形式参数列表的源文本的根解析节点。 |
| [[ECMAScriptCode]] |
一个 |
定义函数体的源文本的根解析节点。 |
| [[ConstructorKind]] |
|
函数是否为派生类 |
| [[Realm]] |
一个 |
创建函数的 |
| [[ScriptOrModule]] |
一个 |
创建函数的脚本或模块。 |
| [[ThisMode]] |
|
定义如何在函数的形式参数和代码体中解释this引用。this引用词法封闭函数的 |
| [[Strict]] | 一个Boolean |
如果这是 |
| [[HomeObject]] | 一个Object |
如果函数使用super,这是其[[GetPrototypeOf]]提供super属性查找开始的对象的对象。
|
| [[SourceText]] | Unicode代码点序列 |
定义函数的 |
| [[Fields]] |
|
如果函数是类,这是表示类的非静态字段和相应初始化器的 |
| [[PrivateMethods]] |
|
如果函数是类,这是表示类的非静态私有方法和访问器的列表。 |
| [[ClassFieldInitializerName]] |
一个字符串、一个Symbol、一个 |
如果函数是作为类字段的初始化器创建的,则为字段的 |
| [[IsClassConstructor]] | 一个Boolean |
指示函数是否为类 |
所有ECMAScript
ECMAScript
抽象操作PrepareForOrdinaryCall接受参数F(一个ECMAScript
抽象操作OrdinaryCallBindThis接受参数F(一个ECMAScript
尽管字段初始化器构成函数边界,但调用
抽象操作OrdinaryCallEvaluateBody接受参数F(一个ECMAScript
ECMAScript
抽象操作OrdinaryFunctionCreate接受参数functionPrototype(一个Object)、sourceText(Unicode代码点序列)、ParameterList(一个
抽象操作AddRestrictedFunctionProperties接受参数F(一个
此函数是%ThrowTypeError%内在对象。
调用时执行以下步骤:
此函数的[[Extensible]]内部插槽的值为
此函数的
此函数的
抽象操作MakeConstructor接受参数F(一个ECMAScript
抽象操作MakeClassConstructor接受参数F(一个ECMAScript
抽象操作MakeMethod接受参数F(一个ECMAScript
抽象操作DefineMethodProperty接受参数homeObject(一个Object)、key(一个
抽象操作SetFunctionName接受参数F(一个
抽象操作SetFunctionLength接受参数F(一个
抽象操作FunctionDeclarationInstantiation接受参数func(一个ECMAScript
调用时执行以下步骤:
内置
除了每个
内置
内置
内置
实现可以提供本规范中未定义的其他内置
内置
内置
抽象操作BuiltinCallOrConstruct接受参数F(内置
当从
抽象操作CreateBuiltinFunction接受参数behaviour(
本规范中定义的每个内置函数都是通过调用CreateBuiltinFunction抽象操作创建的。
本规范定义了几种内置
如果对象的[[Call]]和(如果适用)[[Construct]]内部方法使用以下实现,其他基本内部方法使用
| 内部插槽 | 类型 | 描述 |
|---|---|---|
| [[BoundTargetFunction]] | 可调用对象 |
被包装的 |
| [[BoundThis]] |
|
调用包装函数时总是作为 |
| [[BoundArguments]] |
|
一个值列表,其元素用作对包装函数的任何调用的前几个参数。 |
抽象操作BoundFunctionCreate接受参数targetFunction(
数组是一个
如果对象的[[DefineOwnProperty]]内部方法使用以下实现,其他基本内部方法使用
抽象操作ArrayCreate接受参数length(非负
抽象操作ArraySpeciesCreate接受参数originalArray(对象)和length(非负
抽象操作ArraySetLength接受参数A(数组)和Desc(
字符串对象是一个
如果对象的[[GetOwnProperty]]、[[DefineOwnProperty]]和[[OwnPropertyKeys]]内部方法使用以下实现,其他基本内部方法使用
抽象操作StringCreate接受参数value(字符串)和prototype(对象),返回
抽象操作StringGetOwnProperty接受参数S(具有[[StringData]]内部插槽的对象)和P(
大多数ECMAScript函数向其代码提供一个arguments对象。根据函数定义的特征,其arguments对象要么是
如果对象的内部方法使用以下实现,其他未在此指定的方法使用
虽然
Object.prototype.toString(
ParameterMap对象及其属性值被用作指定arguments对象与参数绑定对应关系的设备。ParameterMap对象和作为其属性值的对象不能从ECMAScript代码中直接观察到。ECMAScript实现不需要实际创建或使用此类对象来实现指定的语义。
普通arguments对象定义一个名为
抽象操作CreateUnmappedArgumentsObject接受参数argumentsList(
抽象操作CreateMappedArgumentsObject接受参数func(对象)、formals(
抽象操作MakeArgGetter接受参数name(字符串)和env(
抽象操作MakeArgSetter接受参数name(字符串)和env(
因为对于任何数字 n,
如果一个对象的 [[PreventExtensions]]、[[GetOwnProperty]]、[[HasProperty]]、[[DefineOwnProperty]]、[[Get]]、[[Set]]、[[Delete]] 和 [[OwnPropertyKeys]] 内部方法使用本节中的定义,并且其他基本内部方法使用
TypedArray
带缓冲区见证记录 是一个用于封装
TypedArray 带缓冲区见证记录具有
| 字段名称 | 值 | 含义 |
|---|---|---|
| [[Object]] |
一个 |
其缓冲区字节长度被加载的 |
| [[CachedBufferByteLength]] |
一个非负 |
创建 |
抽象操作 MakeTypedArrayWithBufferWitnessRecord 接受参数 obj(一个
抽象操作 TypedArrayCreate 接受参数 prototype(一个对象)并返回一个
抽象操作 TypedArrayByteLength 接受参数 taRecord(一个
抽象操作 TypedArrayLength 接受参数 taRecord(一个
抽象操作 IsTypedArrayOutOfBounds 接受参数 taRecord(一个
抽象操作 IsTypedArrayFixedLength 接受参数 O(一个
抽象操作 IsValidIntegerIndex 接受参数 O(一个
抽象操作 TypedArrayGetElement 接受参数 O(一个
抽象操作 TypedArraySetElement 接受参数 O(一个
此操作总是显得成功,但是当尝试写入
抽象操作 IsArrayBufferViewOutOfBounds 接受参数 O(一个
export * 导出项间接导出的任何绑定。每个字符串值自己的
如果一个对象的 [[GetPrototypeOf]]、[[SetPrototypeOf]]、[[IsExtensible]]、[[PreventExtensions]]、[[GetOwnProperty]]、[[DefineOwnProperty]]、[[HasProperty]]、[[Get]]、[[Set]]、[[Delete]] 和 [[OwnPropertyKeys]]
内部方法使用本节中的定义,并且其他基本内部方法使用
ResolveExport 是无副作用的。每当使用特定的 exportName、resolveSet
对作为参数调用此操作时,它必须返回相同的结果。实现可能选择预计算或缓存每个
抽象操作 ModuleNamespaceCreate 接受参数 module(一个
如果一个对象的 [[SetPrototypeOf]] 内部方法使用以下实现,则该对象是一个 不可变原型异质对象。(其他基本内部方法可以使用任何实现,取决于所涉及的特定
与其他
抽象操作 SetImmutablePrototype 接受参数 O(一个对象)和 V(一个对象或
代理对象是一个
如果一个对象的基本内部方法(包括 [[Call]] 和 [[Construct]],如果适用)使用本节中的定义,则该对象是一个 代理异质对象。这些内部方法在
| 内部方法 | 处理器方法 |
|---|---|
| [[GetPrototypeOf]] |
getPrototypeOf
|
| [[SetPrototypeOf]] |
setPrototypeOf
|
| [[IsExtensible]] |
isExtensible
|
| [[PreventExtensions]] |
preventExtensions
|
| [[GetOwnProperty]] |
getOwnPropertyDescriptor
|
| [[DefineOwnProperty]] |
defineProperty
|
| [[HasProperty]] |
has
|
| [[Get]] |
get
|
| [[Set]] |
set
|
| [[Delete]] |
deleteProperty
|
| [[OwnPropertyKeys]] |
ownKeys
|
| [[Call]] |
apply
|
| [[Construct]] |
construct
|
当调用处理器方法来提供代理对象内部方法的实现时,处理器方法将代理的目标对象作为参数传递。代理的处理器对象不一定具有与每个基本内部方法相对应的方法。如果处理器对象没有与内部陷阱相对应的方法,则在代理上调用内部方法会导致在代理的目标对象上调用相应的内部方法。
代理对象的 [[ProxyHandler]] 和 [[ProxyTarget]]
内部插槽在创建对象时总是被初始化,通常不能被修改。某些代理对象以允许它们随后被撤销的方式创建。当代理被撤销时,其 [[ProxyHandler]] 和 [[ProxyTarget]] 内部插槽被设置为
因为代理对象允许通过任意 ECMAScript 代码提供内部方法的实现,所以可以定义一个代理对象,其处理器方法违反了
在以下算法描述中,假设 O 是一个 ECMAScript 代理对象,P 是一个
代理对象的 [[GetPrototypeOf]] 强制执行以下不变量:
代理对象的 [[SetPrototypeOf]] 强制执行以下不变量:
代理对象的 [[IsExtensible]] 强制执行以下不变量:
代理对象的 [[PreventExtensions]] 强制执行以下不变量:
代理对象的 [[GetOwnProperty]] 强制执行以下不变量:
代理对象的 [[HasProperty]] 强制执行以下不变量:
代理对象的 [[Delete]] 强制执行以下不变量:
代理对象的 [[Construct]] 强制执行以下不变量:
抽象操作 ValidateNonRevokedProxy 接受参数 proxy(一个
抽象操作 ProxyCreate 接受参数 target(一个
ECMAScript 源文本是一个 Unicode 码点序列。所有从 U+0000 到 U+10FFFF 的 Unicode
码点值,包括代理码点,都可以出现在 ECMAScript 语法允许的 ECMAScript 源文本中。用于存储和交换 ECMAScript
源文本的实际编码与本规范无关。无论外部源文本编码如何,符合要求的 ECMAScript 实现都会将源文本处理为等效的
组合字符序列的组成部分被视为单独的 Unicode 码点,即使用户可能认为整个序列是一个字符。
在字符串字面量、正则表达式字面量、模板字面量和标识符中,任何 Unicode 码点也可以使用明确表示码点数值的 Unicode 转义序列来表示。在注释中,这样的转义序列作为注释的一部分被有效忽略。
ECMAScript 在 Unicode 转义序列的行为上与 Java 编程语言不同。在 Java 程序中,如果 Unicode 转义序列 \u000A
出现在单行注释中,它会被解释为行终止符(Unicode 码点 U+000A 是换行符 (LF)),因此下一个码点不是注释的一部分。同样,如果 Unicode 转义序列
\u000A 出现在 Java 程序的字符串字面量中,它同样被解释为行终止符,这在字符串字面量中是不允许的——必须写 \n 而不是
\u000A 来使换行符 (LF) 成为字符串字面量值的一部分。在 ECMAScript 程序中,出现在注释中的 Unicode
转义序列永远不会被解释,因此不能促成注释的终止。同样,出现在 ECMAScript 程序字符串字面量中的 Unicode
转义序列总是对字面量有贡献,永远不会被解释为行终止符或可能终止字符串字面量的码点。
抽象操作 UTF16EncodeCodePoint 接受参数 cp(一个 Unicode 码点)并返回一个字符串。它在被调用时执行以下步骤:
抽象操作 CodePointsToString 接受参数 text(一个 Unicode 码点序列)并返回一个字符串。它将 text
转换为字符串值,如
抽象操作 UTF16SurrogatePairToCodePoint 接受参数 lead(一个码元)和 trail(一个码元)并返回一个码点。形成
UTF-16
抽象操作 CodePointAt 接受参数 string(一个字符串)和 position(一个非负
抽象操作 StringToCodePoints 接受参数 string(一个字符串)并返回一个码点的
抽象操作 ParseText 接受参数 sourceText(一个字符串或 Unicode 码点序列)和 goalSymbol(ECMAScript
语法中的一个非终结符)并返回一个
另见第
ECMAScript 代码有四种类型:
eval 函数的源文本。更准确地说,如果内置 eval
函数的参数 eval 调用的 eval
代码是该 函数代码 是被解析以提供 ECMAScript
此外,如果上述源文本被解析为:
那么,该声明或表达式的
将
指令序言是作为
Use Strict 指令
是 "use strict" 或 'use strict'。一个
一个
ECMAScript 句法单元可以使用非限制性或严格模式语法和语义(
eval
的调用是包含在严格模式代码中的 不是严格模式代码的 ECMAScript 代码称为 非严格代码。
抽象操作 IsStrict 接受参数 node(一个
ECMAScript 实现可以支持对函数
ECMAScript
在某些情况下,词法输入元素的识别对消费输入元素的句法语法上下文很敏感。这需要词法语法具有多个
使用多个词法目标确保不存在会影响自动分号插入的词法歧义。例如,不存在既允许前导除法或除法赋值又允许前导
a = b
/hi/g.exec(c).map(d);
其中
a = b / hi / g.exec(c).map(d);
Unicode 格式控制字符(即 Unicode 字符数据库中类别为 "Cf" 的字符,如从左到右标记或从右到左标记)是在缺乏用于此目的的高级协议(如标记语言)的情况下用于控制文本范围格式的控制代码。
允许格式控制字符出现在源文本中是有用的,以便于编辑和显示。所有格式控制字符都可以在注释中以及字符串字面量、模板字面量和正则表达式字面量中使用。
U+FEFF(零宽度无间断空格)是一个格式控制字符,主要用于文本的开头,以将其标记为 Unicode 并允许检测文本的编码和字节顺序。用于此目的的 <ZWNBSP>
字符有时也可能出现在文本开头之后,例如作为连接文件的结果。在
空白码点用于改善源文本的可读性并将标记(不可分割的词法单元)彼此分离,但在其他方面是无关紧要的。空白码点可以出现在任意两个标记之间以及输入的开始或结束处。空白码点可以出现在
ECMAScript 空白码点列在
| 码点 | 名称 | 缩写 |
|---|---|---|
U+0009
|
字符制表符 | <TAB> |
U+000B
|
行制表符 | <VT> |
U+000C
|
换页符 (FF) | <FF> |
U+FEFF
|
零宽度无间断空格 | <ZWNBSP> |
| 通用类别 "Space_Separator" 中的任何码点 | <USP> |
U+0020(空格)和 U+00A0(无间断空格)码点是 <USP> 的一部分。
除了
与空白码点一样,行终止符码点用于改善源文本的可读性并将标记(不可分割的词法单元)彼此分离。但是,与空白码点不同,行终止符对句法语法的行为有一定影响。通常,行终止符可以出现在任意两个标记之间,但在句法语法禁止的少数地方则不行。行终止符还会影响自动分号插入的过程(
行终止符可以出现在
行终止符被包含在正则表达式中 \s 类匹配的空白码点集合中。
ECMAScript 行终止符码点列在
| 码点 | Unicode 名称 | 缩写 |
|---|---|---|
U+000A
|
换行符 (LF) | <LF> |
U+000D
|
回车符 (CR) | <CR> |
U+2028
|
行分隔符 | <LS> |
U+2029
|
段分隔符 | <PS> |
只有
注释可以是单行或多行的。多行注释不能嵌套。
由于单行注释可以包含除 // 标记到行尾的所有码点组成。但是,行尾的
注释的行为类似空白符并被丢弃,除非
本节中的许多产生式在
Hashbang 注释对位置敏感,与其他类型的注释一样,从句法语法的输入元素流中被丢弃。
本标准规定了特定的码点添加:U+0024(美元符号)和 U+005F(下划线)允许出现在
非终结符
非终结符 _。
具有 Unicode 属性 "ID_Start" 和 "ID_Continue" 的码点集合分别包括具有 Unicode 属性 "Other_ID_Start" 和 "Other_ID_Continue" 的码点。
Unicode 转义序列在 \
不贡献任何码点。\
根据 Unicode 标准规范等价的两个
关键字是匹配 固定宽度字体直接出现。ECMAScript 的关键字包括
if、while、async、await 等等。
保留字是不能用作标识符的 if
和 while 是保留字。await 只在异步函数和模块内保留。async
不是保留的;它可以无限制地用作变量名或语句标签。
本规范使用语法产生式和 await 和 yield,都是无条件保留的。await 和 yield 的例外在
总是允许作为标识符且不是关键字的,如 Math、window、toString 和
_;
从不允许作为标识符的,即下面列出的 await 和
yield);
上下文允许作为标识符的,即 await 和 yield;
在 let、static、implements、interface、package、private、protected
和 public;
总是允许作为标识符,但也在某些句法产生式中作为关键字出现,在不允许 as、async、from、get、meta、of、set
和 target。
条件关键字或 上下文关键字这个术语有时用来指属于后三个类别的关键字,因此可以在某些上下文中用作标识符,在其他上下文中用作关键字。
根据 \
\ els\u{65} 来声明名为 "else" 的变量。
enum 目前在本规范中未用作关键字。它是一个未来保留字,留作未来语言扩展中用作关键字。
类似地,implements、interface、package、private、protected
和 public 在
紧跟在
例如:3in 是一个错误,而不是两个输入元素 3 和 in。
数值字面量表示
字符串字面量是用单引号或双引号括起来的 0 个或多个 Unicode 码点。Unicode
码点也可以用转义序列表示。除了结束引号码点、U+005C(反斜杠)、U+000D(回车符)和
U+000A(换行符)之外,所有码点都可以直接出现在字符串字面量中。任何码点都可以以转义序列的形式出现。字符串字面量求值为 ECMAScript String 值。生成这些
String 值时,Unicode 码点按照
非终结符
<LF> 和 <CR> 不能出现在字符串字面量中,除非作为 \n 或 \u000A。
字符串字面量可能出现在将封闭代码置于
function invalid() { "\7"; "use strict"; }
字符串字面量表示
| 转义序列 | 码元值 | Unicode 字符名称 | 符号 |
|---|---|---|---|
\b |
0x0008 |
BACKSPACE | <BS> |
\t |
0x0009 |
CHARACTER TABULATION | <HT> |
\n |
0x000A |
LINE FEED (LF) | <LF> |
\v |
0x000B |
LINE TABULATION | <VT> |
\f |
0x000C |
FORM FEED (FF) | <FF> |
\r |
0x000D |
CARRIAGE RETURN (CR) | <CR> |
\" |
0x0022 |
QUOTATION MARK | " |
\' |
0x0027 |
APOSTROPHE | ' |
\\ |
0x005C |
REVERSE SOLIDUS | \ |
下面的产生式描述了正则表达式字面量的语法,并被输入元素扫描器用来找到正则表达式字面量的结尾。包含
实现可以扩展在
正则表达式字面量不能为空;码元序列 //
不是表示空正则表达式字面量,而是开始单行注释。要指定空正则表达式,请使用:/(?:)/。
大多数 ECMAScript 语句和声明必须以分号结尾。这些分号可以始终显式地出现在源文本中。但是,为了方便起见,在某些情况下可以从源文本中省略这些分号。这些情况通过说分号在这些情况下被自动插入到源代码标记流中来描述。
在以下规则中,"标记"是指使用当前词法
分号插入有三个基本规则:
当从左到右解析源文本时,遇到语法的任何产生式都不允许的标记(称为违规标记),如果满足以下一个或多个条件,则在违规标记之前自动插入分号:
}。),插入的分号将被解析为 do-while 语句的终止分号(但是,前述规则有一个额外的覆盖条件:如果分号随后会被解析为空语句,或者该分号会成为 for 语句头部中的两个分号之一(参见
以下是语法中唯一的受限产生式:
这些受限产生式的实际效果如下:
++ 或 -- 标记时,解析器会将其视为后缀运算符,如果在前一个标记和 ++ 或
-- 标记之间至少有一个 ++ 或
-- 标记之前自动插入分号。
continue、break、return、throw
或 yield 标记,并且在下一个标记之前遇到 continue、break、return、throw 或
yield 标记之后自动插入分号。
=> 标记之前有 async 标记后面在 function 或 (
标记之前有 async 标记不被视为与后续标记相同表达式或类元素的一部分。async 标记后面在 * 标记之前有 给 ECMAScript 程序员的实际建议是:
++ 或 -- 运算符应该与其操作数在同一行。return 或 throw 语句中的 yield 表达式中的
return、throw 或 yield 标记在同一行开始。
break 或 continue 语句中的 break 或 continue 标记在同一行。
=> 应该在同一行。async 标记应该与紧接着的标记在同一行。源代码
{ 1 2 } 3
不是 ECMAScript 语法中的有效句子,即使有自动分号插入规则。相反,源代码
{ 1
2 } 3
也不是有效的 ECMAScript 句子,但通过自动分号插入转换为以下内容:
{ 1
;2 ;} 3;
这是一个有效的 ECMAScript 句子。
源代码
for (a; b
)
不是有效的 ECMAScript 句子,并且不会被自动分号插入更改,因为 for 语句的头部需要分号。自动分号插入永远不会插入 for
语句头部中的两个分号之一。
源代码
return
a + b
通过自动分号插入转换为以下内容:
return;
a + b;
表达式 a + b 不被视为 return 语句要返回的值,因为 return 分开。
源代码
a = b
++c
通过自动分号插入转换为以下内容:
a = b;
++c;
标记 ++ 不被视为应用于变量 b 的后缀运算符,因为 b 和
++ 之间。
源代码
if (a > b)
else c = d
不是有效的 ECMAScript 句子,并且不会被自动分号插入在 else 标记之前更改,即使在该点语法的任何产生式都不适用,因为自动插入的分号随后会被解析为空语句。
源代码
a = b + c
(d + e).print()
不会被自动分号插入转换,因为第二行开始的括号表达式可以被解释为函数调用的参数列表:
a = b + c(d + e).print()
在赋值语句必须以左括号开始的情况下,程序员最好在前一个语句的末尾提供显式分号,而不是依赖自动分号插入。
ECMAScript 程序可以通过依赖自动分号插入以很少分号的风格编写。如上所述,分号不会在每个换行符处插入,自动分号插入可能依赖于跨行终止符的多个标记。
随着新的语法特性被添加到 ECMAScript 中,可能会添加额外的语法产生式,这些产生式会导致依赖自动分号插入的行在解析时改变语法产生式。
就本节而言,如果自动分号插入的情况是可能插入或不插入分号的地方,取决于其前面的源文本,则被认为是有趣的。本节的其余部分描述了这个版本的 ECMAScript 中自动分号插入的许多有趣情况。
在
()。没有分号时,两行一起被视为 [)。没有分号时,两行一起被视为属性访问,而不是 `)。没有分号时,两行一起被解释为带标签的模板(+ 或 -。没有分号时,两行一起被解释为使用相应二元运算符。/ ECMAScript 包含包括"[no
本节的其余部分描述了这个版本的 ECMAScript 中使用"[no
yield 和 await 在语法中被允许作为
let
await 0;
yield 或 await),则是语法错误。
求值
在yield 可以用作标识符。求值 yield 的绑定,就像它是
当处理产生式的实例时
对
this 关键字关于
false,返回 true,返回 数组元素可以在元素列表的开头、中间或末尾省略。当元素列表中的逗号前面没有
使用
对象初始化器是一个表达式,描述对象的初始化,以类似字面量的形式编写。它是零个或多个
在某些上下文中,
除了描述实际的对象初始化器之外,
此产生式的存在是为了让
有关
有关
有关
有关
有关
参见
抽象操作 IsValidRegularExpressionLiteral 接受参数 literal(一个
d、g、i、m、s、u、v
或 y 之外的任何码点,或者如果 flags 包含任何码点超过一次,返回
u,令 u 为 v,令 v 为 抽象操作 TemplateString 接受参数 templateToken(一个
如果 raw 是
抽象操作 GetTemplateObject 接受参数 templateLiteral(一个
模板对象的创建不能导致
本规范的未来版本可能定义模板对象的附加不可枚举属性。
应用于 String.prototype.concat 而不是 + 运算符。
应用于 String.prototype.concat 而不是 + 运算符。
应用于 String.prototype.concat 而不是 + 运算符。
此算法不对 delete
和 typeof 等运算符可以应用于带括号的表达式。
当处理产生式的实例时
使用以下语法细化对
此产生式的存在是为了防止自动分号插入规则(
a?.b
`c`
这样它就不会被解释为两个有效的语句。目的是与没有可选链的类似代码保持一致:
a.b
`c`
这是一个有效的语句,其中不应用自动分号插入。
属性通过名称进行访问,可以使用点记法:
或括号记法:
点记法通过以下语法转换解释:
在行为上等同于
同样地
在行为上等同于
其中 <identifier-name-string> 是
抽象操作 EvaluatePropertyAccessWithExpressionKey 接受参数
baseValue(一个
a[b] = c 的情况下,它将直到 c
求值之后才执行。
抽象操作 EvaluatePropertyAccessWithIdentifierKey 接受参数
baseValue(一个
new 运算符抽象操作 EvaluateNew 接受参数 constructExpr(一个
执行步骤
抽象操作 EvaluateCall 接受参数 func(一个
super 关键字super[b] = c 的情况下,它将直到
c 求值之后才执行。
抽象操作 GetSuperConstructor 不接受参数,返回一个
抽象操作 MakeSuperPropertyReference 接受参数 actualThis(一个
参数列表的求值产生一个值的
?. 开始。抽象操作 EvaluateImportCall 接受参数 specifierExpression(一个
抽象操作 ContinueDynamicImport 接受参数 promiseCapability(一个 import()
标记模板是一个函数调用,其中调用的参数来源于
import.meta 返回的对象提供
HostGetImportMetaProperties 的默认实现是返回新的空
import.meta 返回的对象。
大多数
HostFinalizeImportMeta 的默认实现是返回
delete 运算符
如果派生的
并且
最后一条规则意味着如 delete (((foo))) 这样的表达式由于第一条规则的递归应用而产生
当 delete 运算符出现在delete
运算符出现在
void 运算符即使不使用
typeof 运算符+ 运算符一元 + 运算符将其操作数转换为
- 运算符一元 - 运算符将其操作数转换为数值然后对其取反。对
~)!)* 运算符执行乘法,产生其操作数的乘积。/ 运算符执行除法,产生其操作数的商。% 运算符产生隐含除法中其操作数的余数。+)加法运算符执行字符串连接或数值加法。
-)- 运算符执行减法,产生其操作数的差。
<<)对左操作数执行按位左移操作,移位量由右操作数指定。
>>)对左操作数执行符号填充的按位右移操作,移位量由右操作数指定。
>>>)对左操作数执行零填充的按位右移操作,移位量由右操作数指定。
关系运算符的求值结果总是布尔类型,反映运算符所命名的关系是否在其两个操作数之间成立。
需要 [In] 语法参数来避免关系表达式中的 in 运算符与 for 语句中的 in
运算符混淆。
抽象操作 InstanceofOperator 接受参数 V(
步骤 instanceof 运算符语义。如果对象没有定义或继承 instanceof 语义。
相等运算符的求值结果总是布尔类型,反映运算符所命名的关系是否在其两个操作数之间成立。
根据上述相等性定义:
`${a}` == `${b}`。
+a == +b。
!a == !b。
相等运算符维持以下不变性:
A != B 等价于 !(A == B)。
A == B 等价于 B == A,除了 A 和 B
的求值顺序。
相等运算符并不总是传递的。例如,可能有两个不同的 String 对象,每个代表相同的 String 值;每个 String 对象都会被 ==
运算符认为等于 String 值,但两个 String 对象彼此不相等。例如:
new String("a") == "a" 和 "a" == new String("a") 都是
new String("a") == new String("a") 是 字符串的比较使用简单的代码单元值序列相等性测试。没有尝试使用 Unicode 规范中定义的更复杂的、面向语义的字符或字符串相等性和排序定义。因此,根据 Unicode 标准规范相等的字符串值可能测试为不相等。实际上,此算法假设两个字符串都已经是规范化形式。
&& 或 || 运算符产生的值不一定是布尔类型。产生的值总是两个操作数表达式之一的值。
? : )ECMAScript 中
| assignmentOpText | opText |
|---|---|
**= |
** |
*= |
* |
/= |
/ |
%= |
% |
+= |
+ |
-= |
- |
<<= |
<< |
>>= |
>> |
>>>= |
>>> |
&= |
& |
^= |
^ |
|= |
| |
抽象操作 ApplyStringOrNumericBinaryOperator 接受参数 lVal(一个**、*、/、%、
+、-、<<、>>、
>>>、&、^ 或 |)和
rVal(一个
+,则**,返回 ? /,返回 ? %,返回 ? >>>,返回 ? | opText | operation |
|---|---|
* |
|
+ |
|
- |
|
<< |
|
>> |
|
& |
|
^ |
|
| |
|
| opText | operation |
|---|---|
** |
|
* |
|
/ |
|
% |
|
+ |
|
- |
|
<< |
|
>> |
|
>>> |
|
& |
|
^ |
|
| |
|
在步骤
步骤
抽象操作 EvaluateStringOrNumericBinaryExpression 接受参数
leftOperand(一个
在处理产生式实例的某些情况下
使用以下语法来细化对
通过在访问
, )必须调用
无论控制如何离开
eval 函数的调用都返回值 1:
eval("1;;;;;")
eval("1;{}")
eval("1;var a;")
抽象操作 BlockDeclarationInstantiation 接受参数 code(一个
调用时执行以下步骤:
let 和 const 声明定义的变量作用域限定在let
声明中的
const 声明中。
var 语句声明的变量作用域限定在
如果
它在以下产生式上分段定义:
function 或 class async function 开头,因为这会与 let [ 开头,因为这会与 let
if 语句else] 以通常的方式解决了经典的"悬空 else"问题。也就是说,当关联的
if 的选择在其他方面模糊时,else 与候选 if 中最近的(最内层的)关联。
只有在实现
抽象操作 LoopContinues 接受参数 completion(一个
在
do-while 语句只有在实现
while 语句只有在实现
for 语句只有在实现
抽象操作 ForBodyEvaluation 接受参数 test(一个
抽象操作 CreatePerIterationEnvironment 接受参数
perIterationBindings(一个
for-in、
for-of 和 for-await-of
语句
本节由附录
只有在实现
本节由附录
它在以下产生式上分段定义:
本节由附录
抽象操作 ForIn/OfHeadEvaluation 接受参数
uninitializedBoundNames(一个包含字符串的
抽象操作 ForIn/OfBodyEvaluation 接受参数 lhs(一个
抽象操作 EnumerateObjectProperties 接受参数 O(一个对象),并返回一个
throw 和
return 方法是 next
方法处理对象属性以确定next
方法处理之前被删除的属性将被忽略。如果在枚举期间向目标对象添加新属性,则不保证新添加的属性会在活跃的枚举中被处理。next 方法返回一次。
枚举目标对象的属性包括枚举其原型的属性,以及原型的原型,依此类推,递归进行;但如果原型的属性与已经被next
方法处理过的属性同名,则该原型属性不会被处理。在确定原型对象的属性是否已被处理时,不考虑 [[Enumerable]]
特性的值。原型对象的可枚举属性名必须通过调用 EnumerateObjectProperties 并传递原型对象作为参数来获得。EnumerateObjectProperties
必须通过调用目标对象的 [[OwnPropertyKeys]] 内部方法来获得目标对象的自有
此外,如果 O 或其原型链中的任何对象都不是
ECMAScript 实现不需要直接实现
以下是符合这些规则的 ECMAScript 生成器函数的信息性定义:
function* EnumerateObjectProperties(obj) {
const visited = new Set();
for (const key of Reflect.ownKeys(obj)) {
if (typeof key === "symbol") continue;
const desc = Reflect.getOwnPropertyDescriptor(obj, key);
if (desc) {
visited.add(key);
if (desc.enumerable) yield key;
}
}
const proto = Reflect.getPrototypeOf(obj);
if (proto === null) return;
for (const protoKey of EnumerateObjectProperties(proto)) {
if (!visited.has(protoKey)) yield protoKey;
}
}
For-In
迭代器是表示对某个特定对象进行特定迭代的对象。For-In 迭代器对象永远不能直接被 ECMAScript 代码访问;它们只是为了说明
抽象操作 CreateForInIterator 接受参数 object(一个对象),并返回一个
%ForInIteratorPrototype% 对象:
| 内部槽 | 类型 | 描述 |
|---|---|---|
| [[Object]] | 一个对象 | 正在迭代其属性的对象值。 |
| [[ObjectWasVisited]] | 一个布尔值 |
如果 |
| [[VisitedKeys]] |
一个包含字符串的 |
到目前为止已被此 |
| [[RemainingKeys]] |
一个包含字符串的 |
在迭代其原型的属性之前(如果其原型不是 |
continue 语句static 初始化块边界)嵌套在 break 语句static 初始化块边界)嵌套在 return 语句return 语句使函数停止执行,并且在大多数情况下将值返回给调用者。如果省略了 return
语句可能实际上不会将值返回给调用者。例如,在 try 块中,return
语句的finally 块进行求值期间被另一个
with 语句只有在实现了
switch 语句抽象操作 CaseClauseIsSelected 接受参数 C(一个
此操作不执行 C 的
无论控制如何离开
一个 break
和 continue 语句结合使用。ECMAScript 没有 goto 语句。一个
此规则的替代定义在
抽象操作 IsLabelledFunction 接受参数 stmt(一个
throw 语句try 语句try 语句包含一个可能发生异常情况的代码块,比如运行时错误或 throw 语句。catch
子句提供异常处理代码。当 catch 子句捕获异常时,其
无论控制如何离开
debugger 语句计算
各种 ECMAScript 语言元素会导致创建 ECMAScript
相同
匿名 export default 声明的一部分出现,因此其函数代码总是
在
对于使用
当处理产生式的实例
时,
arguments、super、this 或 new.target
定义局部绑定。arguments、super、this 或 new.target
的任何引用都必须解析为词法封闭环境中的绑定。通常这会是紧邻封闭函数的函数环境。尽管 super
的引用,但在步骤 super 的 super 所需的状态可以通过被
紧跟在 yield 后面的语法上下文需要使用
匿名的 export default 声明的一部分出现,因此其函数代码总是
throw 方法的异常会被传播。来自内部 throw 方法的
next 类似。
throw 方法,这个 throw 将终止
yield* 循环。但首先我们需要给 iterator 一个清理的机会。
yield*
协议违反:iterator 没有 throw 方法。匿名的 export default 声明的一部分出现。
类定义始终是
如果
await 是
早期错误规则确保只有一个名为
本规范中每个未在下面列出的语法产生式替代都隐含地具有以下 AllPrivateIdentifiersValid 的默认定义:
本规范中每个未在下面列出的语法产生式替代都隐含地具有以下 ContainsArguments 的默认定义:
为了便于规范,私有方法和访问器与私有字段一起包含在类实例的 [[PrivateElements]] 槽中。但是,任何给定对象要么拥有给定类定义的所有私有方法和访问器,要么一个都没有。这个特性的设计使得实现可以选择使用不需要单独跟踪每个方法或访问器的策略来实现私有方法和访问器。
例如,实现可以直接将实例私有方法与其相应的 this 值运行过。然后在对象上查找实例私有方法就包括检查定义该方法的类
这与私有字段不同:因为字段初始化器可能在类实例化期间抛出异常,单个对象可能拥有给定类的私有字段的某个真子集,因此私有字段通常必须单独跟踪。
它按以下产生式分段定义:
constructor(...args) { super(...args); }。最显著的区别是,虽然前述
%Array.prototype% 上的 constructor() {}。当存在 [Await] 参数时,await 被解析为
当 await 可能被解析为标识符。这包括以下上下文:
与
当处理产生式实例
时,使用以下语法来细化对
抽象操作 IsInTailPosition 接受参数 call(一个
紧接着返回调用结果的
它按以下产生式分段定义:
抽象操作 PrepareForTailCall 不接受参数,返回
尾位置调用必须在调用目标函数之前释放与当前执行函数
例如,尾位置调用应该仅按目标函数的激活记录大小超出调用函数激活记录大小的量来增长实现的激活记录栈。如果目标函数的激活记录更小,则栈的总大小应该减少。
super,则是语法错误,除非包含 super 的源文本是由 super 的附加 脚本记录 封装了关于被求值脚本的信息。每个脚本记录包含
| 字段名 | 值类型 | 含义 |
|---|---|---|
| [[Realm]] |
一个 |
创建此脚本的 |
| [[ECMAScriptCode]] |
一个 |
解析此脚本源文本的结果。 |
| [[LoadedModules]] |
一个 |
从此脚本导入的说明符字符串到已解析的 |
| [[HostDefined]] |
任何东西(默认值是 |
为需要将附加信息与脚本关联的 |
抽象操作 ParseScript 接受参数 sourceText(
实现可以在对该脚本源文本执行 ParseScript 之前解析脚本源文本并分析其早期错误条件。但是,任何错误的报告必须推迟到本规范实际对该源文本执行 ParseScript 的时候。
抽象操作 ScriptEvaluation 接受参数 scriptRecord(一个
抽象操作 GlobalDeclarationInstantiation 接受参数 script(一个
当为求值脚本建立
调用时执行以下步骤:
var 和 function 绑定(除了由非严格 与显式的 var 或 function 声明不同,直接在
super,则是语法错误。
重复 export default
抽象操作 ImportedLocalNames 接受参数 importEntries(一个
ModuleRequest Record 表示带有给定导入属性的模块导入请求。它由以下字段组成:
| 字段名称 | 值类型 | 含义 |
|---|---|---|
| [[Specifier]] | 一个字符串 | 模块说明符 |
| [[Attributes]] |
一个 |
导入属性 |
LoadedModuleRequest Record 表示模块导入请求以及结果
| 字段名称 | 值类型 | 含义 |
|---|---|---|
| [[Specifier]] | 一个字符串 | 模块说明符 |
| [[Attributes]] |
一个 |
导入属性 |
| [[Module]] |
一个 |
与此模块请求对应的已加载模块 |
ImportAttribute Record 由以下字段组成:
| 字段名称 | 值类型 | 含义 |
|---|---|---|
| [[Key]] | 一个字符串 | 属性键 |
| [[Value]] | 一个字符串 | 属性值 |
抽象操作 ModuleRequestsEqual 接受参数 left(一个
Module Record 封装了单个模块的导入和导出的结构信息。此信息用于链接连接模块集合的导入和导出。Module Record 包含四个仅在求值模块时使用的字段。
出于规范目的,Module Record 值是
Module Record 定义了
| 字段名称 | 值类型 | 含义 |
|---|---|---|
| [[Realm]] |
一个 |
创建此模块的 |
| [[Environment]] |
一个 |
包含此模块顶级绑定的 |
| [[Namespace]] |
一个对象或 |
如果为此模块创建了模块命名空间对象( |
| [[HostDefined]] |
任何内容(默认值为 |
为需要将附加信息与模块关联的 |
| 方法 | 目的 |
|---|---|
| LoadRequestedModules([hostDefined]) |
通过递归加载所有依赖项为链接准备模块,并返回一个 promise。 |
| GetExportedNames([exportStarSet]) |
返回从此模块直接或间接导出的所有名称的列表。 在调用此方法之前,LoadRequestedModules 必须已成功完成。 |
| ResolveExport(exportName [, resolveSet]) |
返回此模块导出的名称的绑定。绑定由 ResolvedBinding
Record 表示,形式为 { [[Module]]:
每次使用特定的 exportName、resolveSet 对作为参数调用此操作时,必须返回相同的结果。 在调用此方法之前,LoadRequestedModules 必须已成功完成。 |
| Link() |
通过传递性地解析所有模块依赖项并创建 在调用此方法之前,LoadRequestedModules 必须已成功完成。 |
| Evaluate() |
返回用于此模块及其依赖项求值的 promise,在成功求值或已成功求值时解析,在求值错误或已求值失败时拒绝。如果 promise
被拒绝,期望 在调用此方法之前,Link 必须已成功完成。 |
抽象操作 EvaluateModuleSync 接受参数 module(一个
Cyclic Module
Record 用于表示可以与
除了
| 字段名称 | 值类型 | 含义 |
|---|---|---|
| [[Status]] |
|
初始为 |
| [[EvaluationError]] |
一个 |
表示求值期间发生的异常的 |
| [[DFSIndex]] |
一个 |
仅在 Link 和 Evaluate 期间使用的辅助字段。如果 [[Status]] 是
|
| [[DFSAncestorIndex]] |
一个 |
仅在 Link 和 Evaluate 期间使用的辅助字段。如果 [[Status]] 是
|
| [[RequestedModules]] |
|
与此模块中的导入关联的 |
| [[LoadedModules]] |
|
从此记录表示的模块用于请求导入具有相对导入属性的模块的说明符字符串到已解析的 |
| [[CycleRoot]] |
一个 |
循环的第一个访问模块,强连通分量的根 DFS 祖先。对于不在循环中的模块,这将是模块本身。一旦 Evaluate 完成,模块的 [[DFSAncestorIndex]] 是其 [[CycleRoot]] 的 [[DFSIndex]]。 |
| [[HasTLA]] | 一个布尔值 |
此模块是否单独异步(例如,如果它是包含顶级等待的 |
| [[AsyncEvaluationOrder]] |
|
此字段初始设置为 |
| [[TopLevelCapability]] |
一个 |
如果此模块是某个循环的 [[CycleRoot]],并且在该循环中的某个模块上调用了
Evaluate(),此字段包含该整个求值的 |
| [[AsyncParentModules]] |
|
如果此模块或依赖项的 [[HasTLA]] 为
|
| [[PendingAsyncDependencies]] |
一个 |
如果此模块有任何异步依赖项,这会跟踪此模块剩余要执行的异步依赖模块数量。 当此字段达到 0 且没有执行错误时,具有异步依赖项的模块将被执行。 |
除了
| 方法 | 目的 |
|---|---|
| InitializeEnvironment() |
初始化模块的 |
| ExecuteModule([promiseCapability]) |
在其 |
GraphLoadingState Record 是一个
| 字段名称 | 值类型 | 含义 |
|---|---|---|
| [[PromiseCapability]] |
一个 |
加载过程完成时要解析的 promise。 |
| [[IsLoading]] | 一个布尔值 | 如果加载过程尚未完成,无论是成功还是出现错误,它都是 true。 |
| [[PendingModulesCount]] |
一个非负 |
它跟踪待处理的 |
| [[Visited]] |
|
它是当前加载过程已加载的 |
| [[HostDefined]] |
任何内容(默认值为 |
它包含从 LoadRequestedModules 调用者传递到 |
以下是
<link rel="preload" as="..."> 标签设置正确的 fetch 目标。
import() 表达式从不设置 hostDefined
参数。
抽象操作 InnerModuleLoading 接受参数 state(一个
抽象操作 ContinueModuleLoading 接受参数 state(一个
抽象操作 InnerModuleLinking 接受参数 module(一个
抽象操作 InnerModuleEvaluation 接受参数 module(一个
模块在被 InnerModuleEvaluation 遍历时处于
当异步循环不是
抽象操作 ExecuteAsyncModule 接受参数 module(一个
抽象操作 GatherAvailableAncestors 接受参数 module
(一个
当根 module 的异步执行完成时,此函数确定能够在此完成时同步执行的模块列表,将它们填充到 execList 中。
抽象操作 AsyncModuleExecutionFulfilled 接受参数
module(一个
抽象操作 AsyncModuleExecutionRejected 接受参数
module(一个
这个非规范性章节提供了一系列常见模块图链接和求值的示例,特别关注错误如何发生。
首先考虑以下简单的模块图:
让我们首先假设没有错误条件。当
然后考虑在成功调用 A.LoadRequestedModules() 后涉及链接错误的情况。如果 C 的
最后,考虑在成功调用 Link() 后涉及求值错误的情况。如果 C 的
现在考虑一种不同类型的错误条件:
在这种情况下,模块 A 声明对某个其他模块的依赖,但该模块不存在
这里加载、链接和求值错误之间的差异是由于以下特征:
现在,考虑一个有循环的模块图:
这里我们假设入口点是模块 A,因此
然后
在成功情况下,循环模块图的求值阶段也发生类似的故事。
现在考虑 A 有链接错误的情况;例如,它尝试从 C 导入一个不存在的绑定。在这种情况下,上述步骤仍然发生,包括从第二次对
A 调用
或者,考虑 A 有求值错误的情况;例如,它的源代码抛出异常。在这种情况下,上述步骤的求值时类似仍然发生,包括从第二次对 A 调用
await
的模块,通过
最后,考虑一个有循环的模块图,其中所有模块都异步完成:
加载和链接像之前一样发生,所有模块最终的 [[Status]] 设置为
调用 A.Evaluate() 对 A、B 和 D 调用
|
字段
|
A | B | C | D | E |
|---|---|---|---|---|---|
| [[DFSIndex]] | 0 | 1 | 3 | 2 | 4 |
| [[DFSAncestorIndex]] | 0 | 0 | 0 | 0 | 4 |
| [[Status]] | |||||
| [[AsyncEvaluationOrder]] | 4 | 1 | 3 | 0 | 2 |
| [[AsyncParentModules]] | « » | « A » | « A » | « B, C » | « C » |
| [[PendingAsyncDependencies]] | 2(B 和 C) | 1(D) | 2(D 和 E) | 0 | 0 |
让我们假设 E 首先完成执行。当发生这种情况时,调用
|
字段
|
C | E |
|---|---|---|
| [[DFSIndex]] | 3 | 4 |
| [[DFSAncestorIndex]] | 0 | 4 |
| [[Status]] | ||
| [[AsyncEvaluationOrder]] | 3 | 2 |
| [[AsyncParentModules]] | « A » | « C » |
| [[PendingAsyncDependencies]] | 1(D) | 0 |
D 接下来完成(因为它是唯一仍在执行的模块)。当发生这种情况时,再次调用 await,可能与 B 并行)。更新模块的字段如
|
字段
|
B | C | D |
|---|---|---|---|
| [[DFSIndex]] | 1 | 3 | 2 |
| [[DFSAncestorIndex]] | 0 | 0 | 0 |
| [[Status]] | |||
| [[AsyncEvaluationOrder]] | 1 | 3 | 0 |
| [[AsyncParentModules]] | « A » | « A » | « B, C » |
| [[PendingAsyncDependencies]] | 0 | 0 | 0 |
让我们假设 C 接下来完成执行。当发生这种情况时,再次调用
|
字段
|
A | C |
|---|---|---|
| [[DFSIndex]] | 0 | 3 |
| [[DFSAncestorIndex]] | 0 | 0 |
| [[Status]] | ||
| [[AsyncEvaluationOrder]] | 4 | 3 |
| [[AsyncParentModules]] | « » | « A » |
| [[PendingAsyncDependencies]] | 1(B) | 0 |
然后,B 完成执行。当发生这种情况时,再次调用
|
字段
|
A | B |
|---|---|---|
| [[DFSIndex]] | 0 | 1 |
| [[DFSAncestorIndex]] | 0 | 0 |
| [[Status]] | ||
| [[AsyncEvaluationOrder]] | 4 | 1 |
| [[AsyncParentModules]] | « » | « A » |
| [[PendingAsyncDependencies]] | 0 | 0 |
最后,A 完成执行。当发生这种情况时,再次调用
|
字段
|
A |
|---|---|
| [[DFSIndex]] | 0 |
| [[DFSAncestorIndex]] | 0 |
| [[Status]] | |
| [[AsyncEvaluationOrder]] | 4 |
| [[AsyncParentModules]] | « » |
| [[PendingAsyncDependencies]] | 0 |
或者,考虑失败情况,其中 C 在 B 完成执行之前执行失败并返回错误。当发生这种情况时,调用
|
字段
|
A | C |
|---|---|---|
| [[DFSIndex]] | 0 | 3 |
| [[DFSAncestorIndex]] | 0 | 0 |
| [[Status]] | ||
| [[AsyncEvaluationOrder]] | 4 | 3 |
| [[AsyncParentModules]] | « » | « A » |
| [[PendingAsyncDependencies]] | 1(B) | 0 |
| [[EvaluationError]] | C 的求值错误 |
A 将被拒绝,错误与 C 相同,因为 C 将用 C 的错误对 A
调用
|
字段
|
A |
|---|---|
| [[DFSIndex]] | 0 |
| [[DFSAncestorIndex]] | 0 |
| [[Status]] | |
| [[AsyncEvaluationOrder]] | 4 |
| [[AsyncParentModules]] | « » |
| [[PendingAsyncDependencies]] | 0 |
| [[EvaluationError]] | C 的 |
然后,B 完成执行且没有错误。当发生这种情况时,再次调用
|
字段
|
A | B |
|---|---|---|
| [[DFSIndex]] | 0 | 1 |
| [[DFSAncestorIndex]] | 0 | 0 |
| [[Status]] | ||
| [[AsyncEvaluationOrder]] | 4 | 1 |
| [[AsyncParentModules]] | « » | « A » |
| [[PendingAsyncDependencies]] | 0 | 0 |
| [[EvaluationError]] | C 的 |
源文本模块记录用于表示从使用
除了在
| 字段名称 | 值类型 | 含义 |
|---|---|---|
| [[ECMAScriptCode]] |
一个 |
使用 |
| [[Context]] |
一个 |
与此模块关联的 |
| [[ImportMeta]] |
一个对象或 |
通过 import.meta 元属性暴露的对象。在被 ECMAScript 代码访问之前为
|
| [[ImportEntries]] |
一个 |
从此模块代码派生的 ImportEntry 记录的 |
| [[LocalExportEntries]] |
一个 |
从此模块代码派生的 ExportEntry 记录的 |
| [[IndirectExportEntries]] |
一个 |
从此模块代码派生的 ExportEntry 记录的 export * as namespace 声明的导出。
|
| [[StarExportEntries]] |
一个 |
从此模块代码派生的 ExportEntry 记录的 export * 声明,不包括 export * as namespace 声明。
|
ImportEntry
记录是一个
| 字段名称 | 值类型 | 含义 |
|---|---|---|
| [[ModuleRequest]] |
一个 |
表示 |
| [[ImportName]] |
一个字符串或 |
由 [[ModuleRequest]] 标识的模块导出所需绑定的名称。值
|
| [[LocalName]] | 一个字符串 | 用于从导入模块内部本地访问导入值的名称。 |
| 导入语句形式 | [[ModuleRequest]] | [[ImportName]] | [[LocalName]] |
|---|---|---|---|
import v from "mod";
|
|
|
|
import * as ns from "mod";
|
|
|
|
import {x} from "mod";
|
|
|
|
import {x as v} from "mod";
|
|
|
|
import "mod";
|
不创建 |
||
ExportEntry
记录是一个
| 字段名称 | 值类型 | 含义 |
|---|---|---|
| [[ExportName]] |
一个字符串或 |
此模块用于导出此绑定的名称。 |
| [[ModuleRequest]] |
一个 |
表示 |
| [[ImportName]] |
一个字符串、 |
由 [[ModuleRequest]] 标识的模块导出所需绑定的名称。
如果 export * as ns from "mod" 声明。
export * from "mod" 声明。
|
| [[LocalName]] |
一个字符串或 |
用于从导入模块内部本地访问导出值的名称。如果导出值在模块内部不可本地访问,则为 |
| 导出语句形式 | [[ExportName]] | [[ModuleRequest]] | [[ImportName]] | [[LocalName]] |
|---|---|---|---|---|
export var v;
|
|
|
|
|
export default function f() {}
|
|
|
|
|
export default function () {}
|
|
|
|
|
export default 42;
|
|
|
|
|
export {x};
|
|
|
|
|
export {v as x};
|
|
|
|
|
export {x} from "mod";
|
|
|
|
|
export {v as x} from "mod";
|
|
|
|
|
export * from "mod";
|
|
|
|
|
export * as ns from "mod";
|
|
|
|
|
以下定义指定了
抽象操作 ParseModule 接受参数 sourceText(
await。
实现可能在对该模块源文本求值 ParseModule 之前解析模块源文本并分析其早期错误条件。然而,任何错误的报告都必须推迟到本规范实际对该源文本执行 ParseModule 的时刻。
以下是
GetExportedNames 不会过滤掉或为具有歧义星号导出绑定的名称抛出异常。
ResolveExport 尝试将导入绑定解析为实际的定义模块和本地绑定名称。定义模块可能是调用此方法的
如果找到定义模块,返回一个
调用时执行以下步骤:
default 导出。
default 导出不能由 export * from "mod" 声明提供。
* 导入。
以下是
合成模块记录用于表示由规范定义的模块的信息。其导出名称在创建时静态定义,而其对应的值可以通过
除了
抽象操作 CreateDefaultExportSyntheticModule 接受参数
defaultExport(一个
抽象操作 ParseJSONModule 接受参数 source(一个字符串),返回
抽象操作 SetSyntheticModuleExport 接受参数 module(一个
以下是
抽象操作 GetImportedModule 接受参数 referrer(一个
HostLoadImportedModule 的实现必须符合以下要求:
如果此操作被多次调用,使用两个 (referrer, moduleRequest) 对,满足:
并且它执行
如果 moduleRequest.[[Attributes]] 有一个条目
entry,使得 entry.[[Key]] 是
执行的实际过程是
抽象操作 FinishLoadingImportedModule 接受参数 referrer(一个
抽象操作 AllImportAttributesSupported 接受参数 attributes(一个包含
HostGetSupportedImportAttributes 的实现必须符合以下要求:
HostGetSupportedImportAttributes 的默认实现是返回一个新的空
抽象操作 GetModuleNamespace 接受参数 module(
GetModuleNamespace 永远不会抛出异常。相反,无法解析的名称在此时简单地从命名空间中排除。除非它们都是未在任何地方明确请求的歧义星号导出,否则稍后会导致真正的链接错误。
上述规则意味着
ExportedBindings 是与
它在以下产生式上分段定义:
ExportedNames 是
它在以下产生式上分段定义:
实现必须在评估相关的 ECMAScript 语言结构时报告大部分错误。早期错误是可以在评估包含错误的 eval 时报告,并阻止 eval
代码的评估。所有不是
实现必须将本规范的"静态语义:早期错误"子条款中列出的任何条件的出现报告为
即使编译器可以证明结构在任何情况下都不能无错误地执行,实现也不应将其他类型的错误视为
实现应按规定报告所有错误,除了以下情况:
eval、使用正则表达式字面量或使用 Function 或 RegExp 实现不得以以下方式扩展本规范:
bind 方法创建的函数也不得创建这样的自有属性。
toLocaleString 的方法)不得扩展,除非在 ECMA-402 中指定。
: 紧跟由 每当 ECMAScript
除非另有规定,可作为函数调用的内置对象是内置
许多内置对象都是函数:它们可以用参数调用。其中一些还是 new
操作符一起使用的函数。对于每个内置函数,本规范描述了该函数所需的参数和该 new 表达式返回的特定对象实例的属性。
除非在特定函数的描述中另有规定,如果内置函数或
除非在特定函数的描述中另有规定,如果所描述的内置函数或
鼓励向内置函数集添加附加功能的实现通过添加新函数而不是向现有函数添加新参数来实现。
除非另有规定,每个内置函数和每个内置 Function.prototype(
除非另有规定,每个内置原型对象都将 Object.prototype(
如果本规范通过算法步骤定义内置
未被标识为
不是
本规范中定义的每个内置函数都是通过调用
每个内置
例如,
除非另有规定,内置
每个内置
对于
除非另有规定,内置
条款
条款
全局对象:
new 操作符一起使用。
此属性具有特性 { [[Writable]]:
Infinity 的值是
NaN 的值是
undefined 的值是
此函数是 %eval% 内置对象。
当被调用时执行以下步骤:
抽象操作 PerformEval 接受参数 x(一个
eval 调用者和
eval 函数本身的 eval 函数的 如果调用上下文的代码或 eval 代码是 let、const 或 class 声明引入的绑定总是在新的
LexicalEnvironment 中实例化。
parameterStrings 表示在使用函数 eval 调用的字符串。direct 表示评估是否是
HostEnsureCanCompileStrings 的默认实现是返回
抽象操作 EvalDeclarationInstantiation 接受参数 body(一个
eval 不会创建被全局词法声明遮蔽的全局 var 声明。此算法的替代版本在
此函数是 %isFinite% 内置对象。
当被调用时执行以下步骤:
此函数是 %isNaN% 内置对象。
当被调用时执行以下步骤:
ECMAScript 代码测试值 X 是否为 X !== X 的表达式。当且仅当 X 是
此函数根据对 string 参数内容作为十进制字面量的解释产生一个数值。
它是 %parseFloat% 内置对象。
当被调用时执行以下步骤:
此函数可能仅将 string 的前导部分解释为数值;它忽略任何不能解释为十进制字面量表示法一部分的代码单元,并且不会给出任何此类代码单元被忽略的指示。
此函数根据指定的 radix 对 string 内容的解释产生一个
它是 %parseInt% 内置对象。
当被调用时执行以下步骤:
统一资源标识符(URI)是标识资源(例如网页或文件)和访问它们的传输协议(例如 HTTP 或 FTP)的字符串。ECMAScript 语言本身不提供对使用 URI
的任何支持,除了本节中描述的编码和解码 URI 的函数。encodeURI 和 decodeURI 旨在与完整的 URI
一起工作;它们假设任何保留字符都旨在具有特殊含义(例如,作为分隔符),因此不进行编码。encodeURIComponent 和
decodeURIComponent 旨在与 URI 的各个组件一起工作;它们假设任何保留字符表示文本,必须编码以避免在组件是完整 URI 的一部分时具有特殊含义。
保留字符集基于 RFC 2396,不反映更新的 RFC 3986 引入的更改。
许多 ECMAScript 实现提供操作网页的附加函数和方法;这些函数超出了本标准的范围。
此函数计算 URI 的新版本,其中每个可能由 encodeURI 函数引入的转义序列和 UTF-8 编码都被其表示的代码点的 UTF-16 编码替换。不可能由
encodeURI 引入的转义序列不被替换。
它是 %decodeURI% 内置对象。
当被调用时执行以下步骤:
此函数计算 URI 的新版本,其中每个可能由 encodeURIComponent 函数引入的转义序列和 UTF-8 编码都被其表示的代码点的 UTF-16
编码替换。
它是 %decodeURIComponent% 内置对象。
当被调用时执行以下步骤:
此函数计算 UTF-16 编码(
它是 %encodeURI% 内置对象。
当被调用时执行以下步骤:
此函数计算 UTF-16 编码(
它是 %encodeURIComponent% 内置对象。
当被调用时执行以下步骤:
抽象操作 Encode 接受参数 string(一个字符串)和 extraUnescaped(一个字符串),返回一个包含字符串的
因为百分号编码用于表示单个八位字节,所以单个代码点可能表示为多个连续的转义序列(其 8 位 UTF-8 代码单元的每一个对应一个)。
抽象操作 Decode 接受参数 string(一个字符串)和 preserveEscapeSet(一个字符串),返回一个包含字符串的
RFC 3629 禁止解码无效的 UTF-8 八位字节序列。例如,无效序列 0xC0 0x80 不得解码为代码单元 0x0000。Decode
算法的实现在遇到此类无效序列时必须抛出
抽象操作 ParseHexOctet 接受参数 string(一个字符串)和 position(一个非负
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
参见
Object
extends 子句的值。此函数在被调用时执行以下步骤:
Object
此函数从一个或多个源对象复制所有可枚举自有属性的值到 target 对象。
当被调用时执行以下步骤:
此函数的
此函数创建一个具有指定原型的新对象。
当被调用时执行以下步骤:
此函数添加自有属性和/或更新对象现有自有属性的特性。
当被调用时执行以下步骤:
抽象操作 ObjectDefineProperties 接受参数 O(一个对象)和 Properties(一个
此函数添加一个自有属性和/或更新对象现有自有属性的特性。
当被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
抽象操作 GetOwnPropertyKeys 接受参数 O(一个
此函数在被调用时执行以下步骤:
callback 应该是一个接受两个参数的函数。groupBy 按升序为 items
中的每个元素调用一次 callback,并构造一个新对象。callback 返回的每个值都被强制转换为
callback 用两个参数调用:元素的值和元素的索引。
groupBy 的返回值是一个不继承自
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
Object.prototype 的初始值是
此属性有特性 { [[Writable]]:
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
Object 原型对象:
Object.prototype.constructor 的初始值是
此方法在被调用时执行以下步骤:
此方法在被调用时执行以下步骤:
此方法在被调用时执行以下步骤:
此方法不考虑原型链中的对象。
此方法在被调用时执行以下步骤:
此方法的可选参数未被使用,但旨在对应 ECMA-402 toLocaleString 方法使用的参数模式。不包含 ECMA-402
支持的实现不得将这些参数位置用于其他目的。
此方法为没有区域敏感的 toString 行为的对象提供通用的 toLocaleString
实现。Array、Number、Date 和 toLocaleString 方法。
ECMA-402 故意不为此默认实现提供替代方案。
此方法在被调用时执行以下步骤:
历史上,此方法偶尔被用来访问 [[Class]]
内部槽的字符串值,该内部槽在此规范的以前版本中用作各种内建对象的名义类型标签。上述 toString 的定义为使用
toString
作为那些特定类型的内建对象测试的遗留代码保持兼容性。它不为其他类型的内建或程序定义的对象提供可靠的类型测试机制。此外,程序可以以会使此类遗留类型测试的可靠性失效的方式使用
此方法在被调用时执行以下步骤:
Object.prototype.__proto__ 是一个
[[Get]] 特性的值是一个不需要参数的内建函数。当被调用时执行以下步骤:
[[Set]] 特性的值是一个接受参数 proto 的内建函数。当被调用时执行以下步骤:
此方法在被调用时执行以下步骤:
此方法在被调用时执行以下步骤:
此方法在被调用时执行以下步骤:
此方法在被调用时执行以下步骤:
Object 实例除了从
Function
Function(…)
等价于使用相同参数的对象创建表达式 new Function(…)。
extends 子句的值。打算继承指定的 Function 行为的子类 super 调用,以创建和初始化具有内建函数行为所需的内部槽的子类实例。所有用于定义 最后一个参数(如果有的话)指定函数的主体(可执行代码);任何前面的参数指定形式参数。
此函数在被调用时执行以下步骤:
为要指定的每个形式参数都有一个参数是允许的但不是必需的。例如,以下三个表达式都产生相同的结果:
new Function("a", "b", "c", "return a+b+c")
new Function("a, b, c", "return a+b+c")
new Function("a,b", "c", "return a+b+c")
抽象操作 CreateDynamicFunction 接受参数 constructor(一个 new 的
new Function("/*", "*/ ) {") 不会计算为函数。CreateDynamicFunction 在它创建的任何 kind 不是
Function
Function.prototype 的值是
此属性有特性 { [[Writable]]:
Function 原型对象:
new 操作符一起用作 Function 原型对象被指定为
此方法在被调用时执行以下步骤:
此方法在被调用时执行以下步骤:
如果 Target 是箭头函数或
此方法在被调用时执行以下步骤:
Function.prototype.constructor 的初始值是
此方法在被调用时执行以下步骤:
此方法在被调用时执行以下步骤:
此属性有特性 { [[Writable]]:
此属性是不可写和不可配置的,以防止可能用于全局暴露绑定函数目标函数的篡改。
此方法的
每个 Function 实例都是一个 ECMAScript Function.prototype.bind 方法(
Function 实例有以下属性:
本规范没有关联上下文名称的匿名函数对象使用空字符串作为
可以用作
此属性有特性 { [[Writable]]:
使用 Function.prototype.bind 创建的
HostHasSourceTextAvailable 的实现必须符合以下要求:
HostHasSourceTextAvailable 的默认实现是返回
Boolean
extends 子句的值。打算继承指定的 Boolean 行为的子类 super 调用,以创建和初始化具有 [[BooleanData]] 内部槽的子类实例。
此函数在被调用时执行以下步骤:
Boolean
Boolean.prototype 的初始值是
此属性有特性 { [[Writable]]:
Boolean 原型对象:
Boolean.prototype.constructor 的初始值是
此方法在被调用时执行以下步骤:
此方法在被调用时执行以下步骤:
抽象操作 ThisBooleanValue 接受参数 value(一个
Boolean 实例是从
Symbol
new 操作符一起使用。extends 子句的值,但对它的 super 调用将导致异常。
此函数在被调用时执行以下步骤:
Symbol
Symbol.asyncIterator 的初始值是众所周知的符号
此属性有特性 { [[Writable]]:
此函数在被调用时执行以下步骤:
GlobalSymbolRegistry 列表是一个只能追加的
Symbol.hasInstance 的初始值是众所周知的符号
此属性有特性 { [[Writable]]:
Symbol.isConcatSpreadable 的初始值是众所周知的符号
此属性有特性 { [[Writable]]:
Symbol.iterator 的初始值是众所周知的符号
此属性有特性 { [[Writable]]:
此函数在被调用时执行以下步骤:
Symbol.match 的初始值是众所周知的符号
此属性有特性 { [[Writable]]:
Symbol.matchAll 的初始值是众所周知的符号
此属性有特性 { [[Writable]]:
Symbol.prototype 的初始值是
此属性有特性 { [[Writable]]:
Symbol.replace 的初始值是众所周知的符号
此属性有特性 { [[Writable]]:
Symbol.search 的初始值是众所周知的符号
此属性有特性 { [[Writable]]:
Symbol.species 的初始值是众所周知的符号
此属性有特性 { [[Writable]]:
Symbol.split 的初始值是众所周知的符号
此属性有特性 { [[Writable]]:
Symbol.toPrimitive 的初始值是众所周知的符号
此属性有特性 { [[Writable]]:
Symbol.toStringTag 的初始值是众所周知的符号
此属性有特性 { [[Writable]]:
Symbol.unscopables 的初始值是众所周知的符号
此属性有特性 { [[Writable]]:
Symbol 原型对象:
Symbol.prototype.constructor 的初始值是
Symbol.prototype.description 是一个
此方法在被调用时执行以下步骤:
抽象操作 SymbolDescriptiveString 接受参数 sym(一个 Symbol)并返回一个字符串。当被调用时执行以下步骤:
此方法在被调用时执行以下步骤:
抽象操作 ThisSymbolValue 接受参数 value(一个
此方法被 ECMAScript 语言操作符调用,以将 Symbol 对象转换为原始值。
当被调用时执行以下步骤:
参数被忽略。
此属性有特性 { [[Writable]]:
此方法的
此属性有特性 { [[Writable]]:
Symbol 实例是从
抽象操作 KeyForSymbol 接受参数 sym(一个 Symbol)并返回一个字符串或
当运行时错误发生时,Error 对象的实例作为异常被抛出。Error 对象也可以作为用户定义异常类的基对象。
当 ECMAScript 实现检测到运行时错误时,它会抛出在
Error
Error(…) 等同于具有相同参数的对象创建表达式 new Error(…)。
extends 子句的值。打算继承指定的 Error 行为的子类 super 调用,以创建和初始化具有 [[ErrorData]] 内部槽的子类实例。
此函数在被调用时执行以下步骤:
Error
Error.prototype 的初始值是
此属性有特性 { [[Writable]]:
Error 原型对象:
Error.prototype.constructor 的初始值是
Error.prototype.message 的初始值是空字符串。
Error.prototype.name 的初始值是
此方法在被调用时执行以下步骤:
Error 实例是从 Object.prototype.toString 中将 Error、AggregateError 和 NativeError 实例标识为
Error 对象。
当检测到运行时错误时,会抛出下面 NativeError 对象之一或 AggregateError 对象的新实例。所有 NativeError
对象共享相同的结构,如
EvalError
此异常当前在本规范中未使用。保留此对象是为了与本规范的先前版本兼容。
RangeError
表示一个不在允许值集合或范围内的值。
ReferenceError
表示检测到无效引用。
SyntaxError
表示发生了解析错误。
TypeError
TypeError 用于表示不成功的操作,当其他 NativeError 对象都不适合表示失败原因时使用。
URIError
表示某个全局 URI 处理函数的使用方式与其定义不兼容。
这些对象中的每一个都具有下面描述的结构,仅在用作
对于每个错误对象,定义中对 NativeError 的引用应替换为
每个 NativeError
NativeError(…) 等同于具有相同参数的对象创建表达式
new NativeError(…)。
extends 子句的值。打算继承指定的 NativeError 行为的子类 super 调用,以创建和初始化具有 [[ErrorData]] 内部槽的子类实例。
每个 NativeError 函数在被调用时执行以下步骤:
"%NativeError.prototype%", « [[ErrorData]] »)。
在步骤
每个 NativeError
NativeError.prototype 的初始值是一个 NativeError
原型对象(
此属性有特性 { [[Writable]]:
每个 NativeError 原型对象:
给定 NativeError
给定 NativeError
NativeError 实例是从其 NativeError 原型对象继承属性的 Object.prototype.toString(
AggregateError
AggregateError(…) 等同于具有相同参数的对象创建表达式 new AggregateError(…)。
extends 子句的值。打算继承指定的 AggregateError 行为的子类 super 调用,以创建和初始化具有 [[ErrorData]] 内部槽的子类实例。此函数在被调用时执行以下步骤:
AggregateError
AggregateError.prototype 的初始值是
此属性有特性 { [[Writable]]:
AggregateError 原型对象:
AggregateError.prototype.constructor 的初始值是
AggregateError.prototype.message 的初始值是空字符串。
AggregateError.prototype.name 的初始值是
AggregateError 实例是从其 Object.prototype.toString(
抽象操作 InstallErrorCause 接受参数 O(一个对象)和 options(一个
Number
extends 子句的值。打算继承指定的 Number 行为的子类 super 调用,以创建和初始化具有 [[NumberData]] 内部槽的子类实例。
此函数在被调用时执行以下步骤:
Number
Number.EPSILON 的值是 1 与大于 1 的可表示为 Number 值的最小值之间差值的幅度的
此属性有特性 { [[Writable]]:
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
此函数与全局 isNaN 函数(
此函数在被调用时执行以下步骤:
Number.MAX_SAFE_INTEGER 的值是
此属性有特性 { [[Writable]]:
Number.MAX_VALUE 的值是
此属性有特性 { [[Writable]]:
Number.MIN_SAFE_INTEGER 的值是
此属性有特性 { [[Writable]]:
Number.MIN_VALUE 的值是
在 Number.MIN_VALUE 的值必须是实现实际能表示的最小非零正值。
此属性有特性 { [[Writable]]:
Number.NaN 的值是
此属性有特性 { [[Writable]]:
Number.NEGATIVE_INFINITY 的值是
此属性有特性 { [[Writable]]:
Number.POSITIVE_INFINITY 的值是
此属性有特性 { [[Writable]]:
Number.prototype 的初始值是
此属性有特性 { [[Writable]]:
Number 原型对象:
除非明确说明,下面定义的 Number 原型对象的方法不是通用的,传递给它们的
方法规范中的短语"此 Number 值"是指通过将方法调用的
Number.prototype.constructor 的初始值是
此方法返回一个字符串,包含以十进制指数记法表示的此 Number 值,有效数字的小数点前有一位数字,小数点后有 fractionDigits 位数字。如果
fractionDigits 是
当被调用时执行以下步骤:
此方法返回一个字符串,包含以十进制定点记法表示的此 Number 值,小数点后有 fractionDigits 位数字。如果
fractionDigits 是
当被调用时执行以下步骤:
对于某些值,toFixed 的输出可能比 toString 更精确,因为 toString
只打印足够的有效数字来区分该数字与相邻的 Number 值。例如,
(1000000000000000128).toString() 返回
(1000000000000000128).toFixed(0) 返回
包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 规范中的规定实现此方法。如果 ECMAScript 实现不包含 ECMA-402 API,则使用此方法的以下规范:
此方法产生一个字符串值,该值表示根据 toString 相同的内容。
此方法的可选参数的含义在 ECMA-402 规范中定义;不包含 ECMA-402 支持的实现不得将这些参数位置用于任何其他用途。
此方法返回一个字符串,包含以十进制指数记法表示的此 Number 值,有效数字的小数点前有一位数字,小数点后有
当被调用时执行以下步骤:
此方法在被调用时执行以下步骤:
此方法不是通用的;如果其
此方法的
抽象操作 ThisNumberValue 接受参数 value(一个
Number 实例是从
BigInt
new 操作符一起使用或被子类化。它可以用作类定义中 extends 子句的值,但对 BigInt super 调用将导致异常。
此函数在被调用时执行以下步骤:
抽象操作 NumberToBigInt 接受参数 number(一个 Number),并返回一个
BigInt
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
BigInt.prototype 的初始值是
此属性有特性 { [[Writable]]:
BigInt 原型对象:
方法规范中的短语"此 BigInt 值"是指通过将方法调用的
BigInt.prototype.constructor 的初始值是
包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 规范中的规定实现此方法。如果 ECMAScript 实现不包含 ECMA-402 API,则使用此方法的以下规范:
此方法产生一个字符串值,该值表示根据 toString 相同的内容。
此方法的可选参数的含义在 ECMA-402 规范中定义;不包含 ECMA-402 支持的实现不得将这些参数位置用于任何其他用途。
此方法在被调用时执行以下步骤:
此方法不是通用的;如果其
抽象操作 ThisBigIntValue 接受参数 value(一个
此属性有特性 { [[Writable]]:
BigInt 实例是从
Math 对象:
new 操作符一起用作 e(自然对数的底)的
此属性有特性 { [[Writable]]:
10 的自然对数的
此属性有特性 { [[Writable]]:
2 的自然对数的
此属性有特性 { [[Writable]]:
e(自然对数的底)的以 10 为底的对数的
此属性有特性 { [[Writable]]:
Math.LOG10E 的值约为 Math.LN10 值的倒数。
e(自然对数的底)的以 2 为底的对数的
此属性有特性 { [[Writable]]:
Math.LOG2E 的值约为 Math.LN2 值的倒数。
π(圆的周长与其直径的比值)的
此属性有特性 { [[Writable]]:
½ 的平方根的
此属性有特性 { [[Writable]]:
Math.SQRT1_2 的值约为 Math.SQRT2 值的倒数。
2 的平方根的
此属性有特性 { [[Writable]]:
此属性有特性 { [[Writable]]:
函数
acos、acosh、asin、asinh、atan、atanh、atan2、cbrt、cos、cosh、exp、expm1、hypot、log、log1p、log2、log10、pow、random、sin、sinh、tan
和 tanh
的行为在此处未被精确指定,除了要求对表示感兴趣的边界情况的某些参数值有特定结果。对于其他参数值,这些函数意图计算熟悉的数学函数结果的近似值,但在近似算法的选择上允许一定的灵活性。总的意图是实现者应该能够在给定硬件平台上为
ECMAScript 使用与该平台上 C 程序员可用的相同数学库。
虽然算法的选择留给实现,但建议(但不是本标准规定的)实现使用 fdlibm 中,这是来自 Sun Microsystems 的可自由分发的数学库(http://www.netlib.org/fdlibm)。
此函数返回 x 的绝对值;结果与 x 具有相同的量级但符号为正。
当被调用时执行以下步骤:
此函数返回 x 的反余弦值。结果以弧度表示,在从
它在被调用时执行以下步骤:
此函数返回 x 的反双曲余弦值。
它在被调用时执行以下步骤:
此函数返回 x 的反正弦值。结果以弧度表示,在从
它在被调用时执行以下步骤:
此函数返回 x 的反双曲正弦值。
它在被调用时执行以下步骤:
此函数返回 x 的反正切值。结果以弧度表示,在从
它在被调用时执行以下步骤:
此函数返回 x 的反双曲正切值。
它在被调用时执行以下步骤:
此函数返回参数 y 和 x 的商
它在被调用时执行以下步骤:
此函数返回 x 的立方根。
它在被调用时执行以下步骤:
此函数返回不小于 x 的最小(最接近 -∞)
它在被调用时执行以下步骤:
Math.ceil(x) 的值与
-Math.floor(-x) 的值相同。
此函数在被调用时执行以下步骤:
如果 n 是
此函数返回 x 的余弦值。参数以弧度表示。
它在被调用时执行以下步骤:
此函数返回 x 的双曲余弦值。
它在被调用时执行以下步骤:
Math.cosh(x) 的值与
(Math.exp(x) + Math.exp(-x)) / 2 的值相同。
此函数返回 x 的指数函数(e 的 x 次幂,其中 e 是自然对数的底)。
它在被调用时执行以下步骤:
此函数返回从 x 的指数函数(e 的 x 次幂,其中 e 是自然对数的底)中减去 1 的结果。该结果以一种即使当 x 的值接近 0 时也很准确的方式计算。
它在被调用时执行以下步骤:
此函数返回不大于 x 的最大(最接近 +∞)
它在被调用时执行以下步骤:
Math.floor(x) 的值与
-Math.ceil(-x) 的值相同。
此函数在被调用时执行以下步骤:
此函数在被调用时执行以下步骤:
此操作与先转换为 binary32 再转换为 binary16 是不同的,因为可能存在双重舍入:例如,考虑数字 k =
并非所有平台都提供从 binary64 转换为 binary16 的原生支持。有各种库可以提供此功能,包括 MIT 许可的 half 库。或者,可以首先在 roundTiesToEven 下从 binary64 转换为 binary32,然后检查结果是否可能导致不正确的双重舍入。可能导致问题的情况可以通过调整 binary32 值的尾数来明确处理,使其成为在 roundTiesToOdd 下执行初始转换时会产生的值。然后在 roundTiesToEven 下将调整后的值转换为 binary16 就会产生正确的值。
给定零个或多个参数,此函数返回其参数的平方和的平方根。
它在被调用时执行以下步骤:
此函数的
实现应当注意避免当此函数以两个或更多参数调用时,在朴素实现中容易发生的溢出和下溢导致的精度损失。
此函数在被调用时执行以下步骤:
此函数返回 x 的自然对数。
它在被调用时执行以下步骤:
此函数返回 1 + x 的自然对数。该结果以一种即使当 x 的值接近零时也很准确的方式计算。
它在被调用时执行以下步骤:
此函数返回 x 的以 10 为底的对数。
它在被调用时执行以下步骤:
此函数返回 x 的以 2 为底的对数。
它在被调用时执行以下步骤:
给定零个或多个参数,此函数对每个参数调用
它在被调用时执行以下步骤:
确定最大值的值比较使用
此函数的
给定零个或多个参数,此函数对每个参数调用
它在被调用时执行以下步骤:
确定最小值的值比较使用
此函数的
此函数在被调用时执行以下步骤:
此函数返回一个具有正号的 Number 值,大于或等于
为不同Math.random 函数必须从连续调用中产生不同的值序列。
此函数返回最接近 x 且为整数的 Number 值。如果两个
它在被调用时执行以下步骤:
Math.round(3.5) 返回 4,但 Math.round(-3.5) 返回 -3。
Math.round(x) 的值并不总是与
Math.floor(x + 0.5) 的值相同。当 x 是
x 小于
Math.round(x) 返回
Math.floor(x + 0.5) 返回
Math.round(x) 也可能因为计算
x + 0.5 时的内部舍入而与
Math.floor(x + 0.5) 的值不同。
此函数返回 x 的符号,指示 x 是正数、负数还是零。
它在被调用时执行以下步骤:
此函数返回 x 的正弦值。参数以弧度表示。
它在被调用时执行以下步骤:
此函数返回 x 的双曲正弦值。
它在被调用时执行以下步骤:
Math.sinh(x) 的值与
(Math.exp(x) - Math.exp(-x)) / 2 的值相同。
此函数返回 x 的平方根。
它在被调用时执行以下步骤:
此函数返回 x 的正切值。参数以弧度表示。
它在被调用时执行以下步骤:
此函数返回 x 的双曲正切值。
它在被调用时执行以下步骤:
Math.tanh(x) 的值与
(Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x)) 的值相同。
此函数返回数字 x 的整数部分,移除任何小数位。如果 x 已经是整数,结果就是 x。
它在被调用时执行以下步骤:
以下
ECMAScript 中的时间测量类似于 POSIX 中的时间测量,特别是共享以前推格里高利历为基础的定义,以 1970 年 1 月 1 日 UTC 午夜开始为纪元,并且将每一天计算为恰好 86,400 秒(每秒为 1000 毫秒)。
ECMAScript 时间值
时间值不考虑 UTC 闰秒——没有时间值表示正闰秒内的瞬间,并且有时间值表示被负闰秒从 UTC 时间线中移除的瞬间。然而,时间值的定义仍然产生与 UTC 的分段对齐,仅在闰秒边界处有不连续性,在闰秒之外没有差异。
Number 可以精确表示从 -9,007,199,254,740,992 到
9,007,199,254,740,992 的所有
1970 年 1 月 1 日 UTC 午夜开始的确切时刻由时间值
在前推格里高利历中,闰年恰好是那些既能被 4 整除,又能被 400 整除或不能被 100 整除的年份。
前推格里高利历的 400 年周期包含 97 个闰年。这产生平均每年 365.2425 天,即 31,556,952,000 毫秒。因此,Number 能以毫秒精度精确表示的最大范围大约是相对于 1970 年的 -285,426 到 285,426 年。本节中指定的时间值支持的较小范围大约是相对于 1970 年的 -273,790 到 273,790 年。
这些常量被以下部分的算法引用。
抽象操作 Day 接受参数 t(一个
抽象操作 TimeWithinDay 接受参数 t(一个
抽象操作 DaysInYear 接受参数 y(一个
抽象操作 DayFromYear 接受参数 y(一个
抽象操作 TimeFromYear 接受参数 y(一个
抽象操作 YearFromTime 接受参数 t(一个
抽象操作 DayWithinYear 接受参数 t(一个
抽象操作 InLeapYear 接受参数 t(一个
抽象操作 MonthFromTime 接受参数 t(一个
抽象操作 DateFromTime 接受参数 t(一个
抽象操作 WeekDay 接受参数 t(一个
抽象操作 HourFromTime 接受参数 t(一个
抽象操作 MinFromTime 接受参数 t(一个
抽象操作 SecFromTime 接受参数 t(一个
抽象操作 msFromTime 接受参数 t(一个
抽象操作 GetUTCEpochNanoseconds 接受参数 year(一个
ECMAScript 中的时区由时区标识符表示,它们是完全由在从
0x0000 到 0x007F 的
主要时区标识符是可用命名时区的首选标识符。 非主要时区标识符是不是主要时区标识符的可用命名时区标识符。 可用命名时区标识符要么是主要时区标识符,要么是非主要时区标识符。 每个可用命名时区标识符恰好与一个可用命名时区关联。 每个可用命名时区恰好与一个主要时区标识符和零个或多个非主要时区标识符关联。
ECMAScript 实现必须支持标识符为
遵循 ECMA-402 国际化 API 规范中描述的时区要求的实现称为时区感知的。
时区感知实现必须支持对应于 IANA 时区数据库的 Zone 和 Link 名称的可用命名时区,并且仅支持这些名称。
在时区感知实现中,主要时区标识符是 Zone 名称,非主要时区标识符是 Link 名称,分别在 IANA 时区数据库中,除非被 ECMA-402 规范中指定的
当输入表示由于负时区转换(例如夏令时结束或由于时区规则变更导致时区偏移减少)而多次出现的本地时间时,返回的
GetNamedTimeZoneEpochNanoseconds 的默认实现,用于不包含任何时区本地政治规则的 ECMAScript 实现,在被调用时执行以下步骤:
2017 年 11 月 5 日在 America/New_York 的凌晨 1:30 重复了两次,所以
GetNamedTimeZoneEpochNanoseconds(
2017 年 3 月 12 日在 America/New_York 的凌晨 2:30 不存在,所以
GetNamedTimeZoneEpochNanoseconds(
返回的
GetNamedTimeZoneOffsetNanoseconds 的默认实现,用于不包含任何时区本地政治规则的 ECMAScript 实现,在被调用时执行以下步骤:
时区偏移值可能是正数或负数。
时区标识符记录是一个
时区标识符记录具有
如果 [[Identifier]] 是一个
为了确保实现在 Date 对象的方法中通常提供的功能级别,建议 SystemTimeZoneIdentifier 返回对应于
例如,如果
抽象操作 LocalTime 接受参数 t(一个
如果实现中没有本地时间 t 的政治规则,结果就是 t,因为
抽象操作 UTC 接受参数 t(一个 Number)并返回一个
输入 t 名义上是一个
如果实现中没有本地时间 t 的政治规则,结果就是 t,因为
2017 年 11 月 5 日在 America/New_York 的凌晨 1:30 重复了两次(回退),但必须解释为 1:30 AM UTC-04 而不是 1:30
AM UTC-05。
在 UTC(
2017 年 3 月 12 日在 America/New_York 的凌晨 2:30 不存在,但必须解释为 2:30 AM UTC-05(相当于 3:30 AM
UTC-04)。
在 UTC(
抽象操作 MakeTime 接受参数 hour(一个 Number)、min(一个 Number)、sec(一个 Number)和 ms(一个 Number)并返回一个 Number。它 计算毫秒数。它在被调用时执行以下步骤:
MakeTime 中的算术是浮点算术,它不满足结合律,所以操作必须按正确的顺序执行。
抽象操作 MakeDay 接受参数 year(一个 Number)、month (一个 Number)和 date(一个 Number)并返回一个 Number。它计算天数。它在被调用时执行以下步骤:
抽象操作 MakeDate 接受参数 day(一个 Number)和 time (一个 Number)并返回一个 Number。它计算毫秒数。它在被调用时执行以下步骤:
抽象操作 MakeFullYear 接受参数 year(一个 Number)并返回一个
抽象操作 TimeClip 接受参数 time(一个 Number)并返回一个 Number。它计算毫秒数。它在被调用时执行以下步骤:
ECMAScript 基于 ISO 8601 日历日期扩展格式的简化版本定义了日期时间的字符串交换格式。格式如下:
YYYY-MM-DDTHH:mm:ss.sssZ
其中各元素如下:
YYYY
|
是推算格里高利历中的年份,作为从 0000 到 9999 的四位十进制数字,或作为由 |
-
|
|
MM
|
是一年中的月份,作为从 01(一月)到 12(十二月)的两位十进制数字。 |
DD
|
是一个月中的日期,作为从 01 到 31 的两位十进制数字。 |
T
|
|
HH
|
是自午夜以来经过的完整小时数,作为从 00 到 24 的两位十进制数字。 |
:
|
|
mm
|
是自小时开始以来的完整分钟数,作为从 00 到 59 的两位十进制数字。 |
ss
|
是自分钟开始以来的完整秒数,作为从 00 到 59 的两位十进制数字。 |
.
|
|
sss
|
是自秒开始以来的完整毫秒数,作为三位十进制数字。 |
Z
|
是 UTC 偏移表示,指定为 HH:mm( |
此格式包括仅日期形式:
YYYY
YYYY-MM
YYYY-MM-DD
它还包括"日期时间"形式,由上述仅日期形式之一紧接一个以下时间形式(可附加可选的 UTC 偏移表示)组成:
THH:mm
THH:mm:ss
THH:mm:ss.sss
包含超出边界或不符合要求元素的字符串不是此格式的有效实例。
由于每一天都以午夜开始和结束,00:00
和 24:00
这两种表示法可用于区分可能与一个日期关联的两个午夜。这意味着以下两种表示法指的是完全相同的时间点:1995-02-04T24:00 和
1995-02-05T00:00。将后一种形式解释为"日历日的结束"与 ISO 8601
一致,尽管该规范将其保留用于描述时间间隔,并且不允许在单个时间点的表示中使用。
不存在指定民用时区缩写(如 CET、EST 等)的国际标准,有时同一缩写甚至用于两个非常不同的时区。出于这个原因,ISO 8601 和此格式都指定时区偏移的数字表示。
涵盖从 1970 年 1 月 1 日向前或向后约 273,790 年的完整Date.parse
带有扩展年份的日期时间值示例:
| -271821-04-20T00:00:00Z | 公元前 271822 年 |
| -000001-01-01T00:00:00Z | 公元前 2 年 |
| +000000-01-01T00:00:00Z | 公元前 1 年 |
| +000001-01-01T00:00:00Z | 公元 1 年 |
| +001970-01-01T00:00:00Z | 公元 1970 年 |
| +002009-12-15T00:00:00Z | 公元 2009 年 |
| +275760-09-13T00:00:00Z | 公元 275760 年 |
ECMAScript 定义了一个来源于 ISO 8601 的 UTC 偏移字符串交换格式。 该格式由以下语法描述。
抽象操作 IsTimeZoneOffsetString 接受参数 offsetString(一个
String)并返回一个 Boolean。返回值指示
offsetString 是否符合
抽象操作 ParseTimeZoneOffsetString 接受参数 offsetString
(一个 String)并返回一个
Date
extends 子句的值使用。打算继承指定 Date 行为的子类 super 调用,以使用 [[DateValue]] 内部槽创建并初始化子类实例。
当调用此函数时,将执行以下步骤:
Date
此函数返回表示调用时 UTC 日期和时间的
此函数对其参数应用
如果字符串符合 MM 或 DD 元素缺失时,使用 HH、mm 或 ss 元素缺失时,使用 sss 元素缺失时,使用
如果 x 是 ECMAScript 某一实现中毫秒数为零的 Date,则在该实现中,以下所有表达式(如果所有相关属性都是初始值)应产生相同的数值:
x.valueOf()
Date.parse(x.toString())
Date.parse(x.toUTCString())
Date.parse(x.toISOString())
然而,下面的表达式
Date.parse(x.toLocaleString())
不要求产生与前三个表达式相同的数值,并且通常当传入的字符串不符合日期时间字符串格式 (toString 或 toUTCString 方法在该实现中产生时,该函数的返回值是
Date.prototype 的初始值是
该属性具有属性 { [[Writable]]:
当调用此函数时,将执行以下步骤:
该函数的
Date 原型对象:
除非另有明确规定,下文定义的 Date 原型对象的方法不是泛型的,传递给它们的
Date.prototype.constructor 的初始值是
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
该方法的
如果未给出 month,本方法表现为 month 的值为 getMonth()。如果未给出
date,则表现为 date 的值为 getDate()。
调用该方法时,执行以下步骤:
该方法的
如果未给出 min,本方法表现为 min 的值为 getMinutes()。如果未给出
sec,则表现为 sec 的值为 getSeconds()。如果未给出
ms,则表现为 ms 的值为 getMilliseconds()。
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
该方法的
如果未给出 sec,本方法表现为 sec 的值为 getSeconds()。如果未给出
ms,则表现为 ms 的值为 getMilliseconds()。
调用该方法时,执行以下步骤:
该方法的
如果未给出 date,本方法表现为 date 的值为 getDate()。
调用该方法时,执行以下步骤:
该方法的
如果未给出 ms,本方法表现为 ms 的值为 getMilliseconds()。
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
该方法的
如果未给出 month,本方法表现为 month 的值为 getUTCMonth()。如果未给出
date,则表现为 date 的值为 getUTCDate()。
调用该方法时,执行以下步骤:
该方法的
如果未给出 min,本方法表现为 min 的值为 getUTCMinutes()。如果未给出
sec,则表现为 sec 的值为 getUTCSeconds()。如果未给出
ms,则表现为 ms 的值为 getUTCMilliseconds()。
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
该方法的
如果未给出 sec,本方法表现为 sec 的值为 getUTCSeconds()。如果未给出
ms,则表现为 ms 的值为 getUTCMilliseconds()。
调用该方法时,执行以下步骤:
该方法的
如果未给出 date,本方法表现为 date 的值为 getUTCDate()。
调用该方法时,执行以下步骤:
该方法的
如果未给出 ms,本方法表现为 ms 的值为 getUTCMilliseconds()。
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
此方法为 JSON.stringify (
调用该方法时,执行以下步骤:
参数会被忽略。
此方法有意设计为泛型;它不要求其 toISOString 方法。
包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 规范实现此方法。如果 ECMAScript 实现未包含 ECMA-402 API,则使用以下规范:
该方法返回一个字符串值。字符串内容是
本方法的可选参数含义在 ECMA-402 规范中定义;未包含 ECMA-402 支持的实现不得将这些参数位置用于其他用途。
包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 规范实现此方法。如果 ECMAScript 实现未包含 ECMA-402 API,则使用以下规范:
该方法返回一个字符串值。字符串内容是
本方法的可选参数含义在 ECMA-402 规范中定义;未包含 ECMA-402 支持的实现不得将这些参数位置用于其他用途。
包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 规范实现此方法。如果 ECMAScript 实现未包含 ECMA-402 API,则使用以下规范:
该方法返回一个字符串值。字符串内容是
本方法的可选参数含义在 ECMA-402 规范中定义;未包含 ECMA-402 支持的实现不得将这些参数位置用于其他用途。
调用该方法时,执行以下步骤:
对于任何 Date d,如果 d.[[DateValue]] 能被
1000 整除,则 Date.parse(d.toString()) 的结果等于
d.valueOf()。参见
此方法不是泛型;如果其
抽象操作 TimeString 接受参数 tv(Number,但不是
抽象操作 DateString 接受参数 tv(Number,但不是
| 编号 | 名称 |
|---|---|
| 编号 | 名称 |
|---|---|
抽象操作 TimeZoneString 接受参数 tv(
抽象操作 ToDateString 接受参数 tv(
调用该方法时,执行以下步骤:
该方法返回一个字符串值,表示与
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
此方法被 ECMAScript 语言运算符调用,用于将 Date 转换为原始值。hint 的允许值为
调用该方法时,执行以下步骤:
该属性具有属性 { [[Writable]]:
本方法的
Date 实例是
String
extends 子句的值使用。打算继承指定 String 行为的子类 super 调用,以用 [[StringData]] 内部槽创建并初始化子类实例。
当调用该函数时,执行以下步骤:
String
该函数可以接收任意数量的参数,这些参数形成余参数 codeUnits。
调用该函数时,执行以下步骤:
该函数的
该函数可以接收任意数量的参数,这些参数形成余参数 codePoints。
调用该函数时,执行以下步骤:
该函数的
String.prototype 的初始值为
该属性具有属性 { [[Writable]]:
该函数可以接收可变数量的参数。第一个参数为 template,其余参数组成
调用该函数时,执行以下步骤:
该函数用于作为标记模板(Tagged Template)(
String 原型对象:
除非另有明确声明,下文定义的 String 原型对象的方法都不是泛型方法,传递给它们的
调用该方法时,执行以下步骤:
此方法有意设计为泛型;它不要求其
此方法返回一个 Number(一个非负的
调用该方法时,执行以下步骤:
此方法有意设计为泛型;它不要求其
调用该方法时,执行以下步骤:
此方法有意设计为泛型;它不要求其
调用此方法时,返回由
调用该方法时,执行以下步骤:
该方法的
此方法有意设计为泛型;它不要求其
String.prototype.constructor 的初始值为
调用该方法时,执行以下步骤:
如果 searchString(转换为 String)码元序列与本对象(转换为 String)中从 endPosition -
length(this) 开始的对应码元相同,则该方法返回
如果第一个参数是 RegExp 抛出异常,是为了允许后续标准版本定义支持此类参数值的扩展。
此方法有意设计为泛型;它不要求其
调用该方法时,执行以下步骤:
如果 searchString 作为
如果第一个参数是 RegExp 抛出异常,是为了允许后续标准版本定义支持此类参数值的扩展。
此方法有意设计为泛型;它不要求其
如果 searchString 作为
调用该方法时,执行以下步骤:
此方法有意设计为泛型;它不要求其
调用该方法时,执行以下步骤:
如果 searchString 作为
调用该方法时,执行以下步骤:
此方法有意设计为泛型;它不要求其
包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 规范实现此方法。如果 ECMAScript 实现未包含 ECMA-402 API,则使用以下规范:
该方法返回一个除
在执行比较前,该方法会按如下步骤准备字符串:
本方法的第二和第三个可选参数的含义在 ECMA-402 规范中定义;未包含 ECMA-402 支持的实现不得将这些参数位置用于其他用途。
实际返回值为
此方法本身不适合作为 Array.prototype.sort 的参数,因为后者需要两个参数的函数。
此方法可依赖 ECMAScript 环境从
// Å ANGSTROM SIGN vs.
// Å LATIN CAPITAL LETTER A + COMBINING RING ABOVE
"\u212B".localeCompare("A\u030A")
// Ω OHM SIGN vs.
// Ω GREEK CAPITAL LETTER OMEGA
"\u2126".localeCompare("\u03A9")
// ṩ LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE vs.
// ṩ LATIN SMALL LETTER S + COMBINING DOT ABOVE + COMBINING DOT BELOW
"\u1E69".localeCompare("s\u0307\u0323")
// ḍ̇ LATIN SMALL LETTER D WITH DOT ABOVE + COMBINING DOT BELOW vs.
// ḍ̇ LATIN SMALL LETTER D WITH DOT BELOW + COMBINING DOT ABOVE
"\u1E0B\u0323".localeCompare("\u1E0D\u0307")
// 가 HANGUL CHOSEONG KIYEOK + HANGUL JUNGSEONG A vs.
// 가 HANGUL SYLLABLE GA
"\u1100\u1161".localeCompare("\uAC00")
关于规范等价的定义和讨论,参见 Unicode 标准第 2 章和第 3 章,以及 Unicode Standard Annex #15, Unicode Normalization Forms 和 Unicode Technical Note #5, Canonical Equivalence in Applications。另见 Unicode Technical Standard #10, Unicode Collation Algorithm。
建议本方法不应遵循 Unicode 兼容等价或 Unicode 标准第 3 章第 3.7 节定义的兼容分解。
此方法有意设计为泛型;它不要求其
调用该方法时,执行以下步骤:
此方法有意设计为泛型;它不要求其
该方法对将
调用该方法时,执行以下步骤:
String.prototype.split
类似,String.prototype.matchAll 通常不应改变其输入。调用该方法时,执行以下步骤:
此方法有意设计为泛型,不要求其
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
抽象操作 StringPaddingBuiltinsImpl 接收参数 O(
抽象操作 StringPad 接收参数 S(字符串)、maxLength(非负
maxLength 参数会被限制,不能小于 S 的长度。
fillString 参数的默认值为
抽象操作 ToZeroPaddedDecimalString 接收参数 n(非负
调用该方法时,执行以下步骤:
此方法会创建由
此方法有意设计为泛型;它不要求其
调用该方法时,执行以下步骤:
此方法有意设计为泛型;它不要求其
抽象操作 GetSubstitution 接收参数
matched(字符串)、str(字符串)、position(非负
调用该方法时,执行以下步骤:
调用该方法时,执行以下步骤:
此方法有意设计为泛型;它不要求其
该方法返回将此对象转换为字符串后的
调用该方法时,执行以下步骤:
此方法有意设计为泛型;它不要求其
该方法返回一个数组,将此对象转换为字符串后的子串存储在其中。子串是通过从左到右查找 separator
的出现位置确定的;这些出现位置不会包含在返回数组的任何字符串中,而是用来分割字符串。separator 的值可以是任意长度的字符串,也可以是具有
调用该方法时,执行以下步骤:
separator 的值可以为空字符串。在这种情况下,separator
不会匹配输入字符串开头或结尾的空
如果
如果 separator 为
此方法有意设计为泛型;它不要求其
调用该方法时,执行以下步骤:
如果 searchString(转换为字符串)的码元序列与本对象(转换为字符串)从 position
开始的对应码元相同,则返回
如果第一个参数是 RegExp 抛出异常,是为了允许后续标准版本定义支持此类参数值的扩展。
此方法有意设计为泛型;它不要求其
该方法返回将此对象转换为字符串后的
如果任一参数为
如果 start 严格大于 end,则交换两者。
调用该方法时,执行以下步骤:
此方法有意设计为泛型;它不要求其
包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 规范实现此方法。如果 ECMAScript 实现未包含 ECMA-402 API,则使用以下规范:
该方法将 String 值作为 UTF-16 编码码点序列解释,如
其行为与 toLowerCase 相同,但旨在根据
该方法的可选参数含义由 ECMA-402 规范定义;未包含 ECMA-402 支持的实现不得将这些参数位置用于其他用途。
此方法有意设计为泛型;它不要求其
包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 规范实现此方法。如果 ECMAScript 实现未包含 ECMA-402 API,则使用以下规范:
该方法将 String 值作为 UTF-16 编码码点序列解释,如
其行为与 toUpperCase 相同,但旨在根据
该方法的可选参数含义由 ECMA-402 规范定义;未包含 ECMA-402 支持的实现不得将这些参数位置用于其他用途。
此方法有意设计为泛型;它不要求其
该方法将 String 值作为 UTF-16 编码码点序列解释,如
调用该方法时,执行以下步骤:
结果必须依据 Unicode 字符数据库中的区域无关大小写映射得出(这不仅包括 UnicodeData.txt
文件,还包括伴随的 SpecialCasing.txt
文件中所有区域无关的映射)。
某些码点的大小写映射可能产生多个码点。在这种情况下,结果字符串的长度可能与源字符串不同。由于 toUpperCase 和
toLowerCase
都具有上下文相关行为,这些方法并不对称。换言之,s.toUpperCase().toLowerCase() 不一定等于
s.toLowerCase()。
此方法有意设计为泛型;它不要求其
调用该方法时,执行以下步骤:
对于 String 对象,此方法恰好返回与 valueOf 方法相同的值。
该方法将 String 值作为 UTF-16 编码码点序列解释,如
其行为与 String.prototype.toLowerCase 完全相同,只是字符串使用 Unicode 默认大小写转换的 toUppercase
算法进行映射。
此方法有意设计为泛型;它不要求其
该方法返回此对象的字符串表示,将所有不是
调用该方法时,执行以下步骤:
该方法将 String 值作为 UTF-16 编码码点序列解释,如
调用该方法时,执行以下步骤:
此方法有意设计为泛型;它不要求其
抽象操作 TrimString 接收参数 string(
空白的定义为
该方法将 String 值作为 UTF-16 编码码点序列解释,如
调用该方法时,执行以下步骤:
此方法有意设计为泛型;它不要求其
该方法将 String 值作为 UTF-16 编码码点序列解释,如
调用该方法时,执行以下步骤:
此方法有意设计为泛型;它不要求其
调用该方法时,执行以下步骤:
抽象操作 ThisStringValue 接收参数 value(
该方法返回一个
调用该方法时,执行以下步骤:
该方法的
String 实例是
String 实例具有
该 String 对象所表示的 String 值中的元素数量。
一旦 String 对象被初始化,此属性不可更改。它具有属性 { [[Writable]]:
String 迭代器是表示对某个特定 String 实例对象的某次特定迭代的对象。String 迭代器对象没有命名的
%StringIteratorPrototype% 对象:
该属性具有属性 { [[Writable]]:
RegExp 对象包含一个正则表达式和相关的标志(flags)。
正则表达式的形式和功能模仿了 Perl 5 编程语言中的正则表达式机制。
RegExp
每个 \u u
\u u
此处前两行等价于 CharacterClass。
本节中的多项产生式在
本节在
PropertyValueAliases.txt),则为语法错误。
PropertyValueAliases.txt
中 General_Category (gc) 属性的属性值或别名,也不是 抽象操作 CountLeftCapturingParensWithin 接收参数 node(一个 (
终结符匹配的 ( 模式字符:
本节在
调用时,执行以下步骤:
抽象操作 CountLeftCapturingParensBefore 接收参数 node(一个
本节在
调用时,执行以下步骤:
抽象操作 MightBothParticipate 接收参数 x(一个
本节在
在以下产生式中分段定义:
“
本节在
在以下产生式中分段定义:
本节在
在以下产生式中分段定义:
| ControlEscape | 数值 | 码点 | Unicode 名称 | 符号 |
|---|---|---|---|---|
t |
9 | U+0009 |
CHARACTER TABULATION | <HT> |
n |
10 | U+000A |
LINE FEED (LF) | <LF> |
v |
11 | U+000B |
LINE TABULATION | <VT> |
f |
12 | U+000C |
FORM FEED (FF) | <FF> |
r |
13 | U+000D |
CARRIAGE RETURN (CR) | <CR> |
\0 表示 <NUL> 字符,且不能后跟十进制数字。
抽象操作 GroupSpecifiersThatMatch 接收参数 thisGroupName(一个
正则表达式模式会按照下述过程被转换为一个
如果一个 u 也不包含 v,则它是 BMP 模式。否则,它是 Unicode 模式。BMP 模式会针对被解释为由处于基本多文种平面(BMP)范围内的
Unicode 码点组成的 16 位值序列的字符串进行匹配。Unicode 模式则针对被解释为用 UTF-16 编码的 Unicode 码点序列的字符串进行匹配。在描述 BMP
模式行为时,“character” 表示单个 16 位的 Unicode BMP 码点。在描述 Unicode 模式行为时,“character” 表示一个 UTF-16
编码的码点(
例如,假设一个模式在源文本中表示为单个非 BMP 字符 U+1D11E(MUSICAL SYMBOL G CLEF)。作为 Unicode 模式解释时,它是一个仅包含该码点
U+1D11E 的元素(字符)
模式会以 ECMAScript 字符串值的形式传递给 RegExp
实现不一定真的需要进行这些 UTF-16 的转换,但本规范要求,模式匹配的语义要如同进行了这些转换一样。
下述描述使用以下内部数据结构:
RegExp Record 是一个
它包含如下字段:
| 字段名 | 值 | 含义 |
|---|---|---|
| [[IgnoreCase]] | 布尔值 | 指示 RegExp 标志中是否出现 |
| [[Multiline]] | 布尔值 | 指示 RegExp 标志中是否出现 |
| [[DotAll]] | 布尔值 | 指示 RegExp 标志中是否出现 |
| [[Unicode]] | 布尔值 | 指示 RegExp 标志中是否出现 |
| [[UnicodeSets]] | 布尔值 | 指示 RegExp 标志中是否出现 |
| [[CapturingGroupsCount]] | 非负 |
RegExp 模式中的 |
Pattern 会被编译为
本节在
在以下产生式中分段定义:
| 正则表达式操作符分隔两个备选项。模式首先尝试匹配左侧 | 跳过的部分中的捕获括号,其值为
/a|ab/.exec("abc")
返回结果为
/((a)|(ab))((c)|(bc))/.exec("abc")
返回数组:
["abc", "a", "a", undefined, "bc", undefined, "bc"]
而不是:
["abc", "ab", undefined, "ab", "c", "c", undefined]
两个备选项的尝试顺序与 direction 的值无关。
连续的
所得
抽象操作 RepeatMatcher 接收参数 m(一个
一个
抽象操作 EmptyMatcher 无参数,返回一个
抽象操作 MatchTwoAlternatives 接收参数 m1(
抽象操作 MatchSequence 接收参数 m1(
本节在
在以下产生式中分段定义:
即使正则表达式使用 y 标志,^ 也只会在 Input 开头或(若
rer.[[Multiline]] 为
形式 (?= )
表示零宽度正向先行断言。其内部模式需在当前位置匹配成功,但当前位置不会推进。lookahead 内部无回溯。
形式 (?! )
表示零宽度负向先行断言。其内部模式需在当前位置匹配失败。
抽象操作 IsWordChar 接收参数 rer(
本节在
在以下产生式中分段定义:
形如 ( )
的括号既用于分组,也用于保存匹配结果。可以通过反向引用、替换字符串或结果数组使用该结果。用 (?: ... )
可禁用捕获行为。
形如 \ 后跟非零十进制数字 n 的转义序列,匹配第 n 个捕获括号的结果。括号数不足 n
是错误。若 n 个括号有但第 n 个未捕获内容,则反向引用总是成功。
抽象操作 CharacterSetMatcher 接收参数 rer(
抽象操作 BackreferenceMatcher 接收参数 rer(
抽象操作 Canonicalize 接收参数 rer(
CaseFolding.txt
提供了 ch 的简单或通用大小写折叠映射,则返回应用该映射后的 ch。当 ß 不会变为 ss 或
SS)。但部分非Basic Latin字符可映射为Basic Latin内字符,如 ſ 会折叠为
s,K 会折叠为 k,因此如 /[a-z]/ui
可匹配这些字符。
当 Ω(U+2126)用 toUppercase 仍为自身,但 toCasefold 会变为
ω。所以 "\u2126" 能被 /[ω]/ui 匹配,不能被
/[ω]/i 匹配。非Basic Latin的字符不会映射到Basic Latin内字符。
抽象操作 UpdateModifiers 接收参数 rer(
本节在
在以下产生式中分段定义:
即使忽略大小写,区间两端字符的大小写在区间确定时依然重要。例如 /[E-F]/i 只匹配 E,
F, e, f,而 /[E-f]/i 匹配 Basic
Latin 字母及 [, \, ], ^,
_, `。
- 可被当作字面量或区间。若在
- U+002D (HYPHEN-MINUS) 的 0 到 9 的十元素 General_Category,
s) 是 PropertyValueAliases.txt
中 General_Category (gc) 属性的 Unicode 属性值或属性值别名,则:
结果通常包含两个或更多区间。当 UnicodeSets 为
抽象操作 CharacterRange 接收参数 A(
抽象操作 HasEitherUnicodeFlag 接收参数 rer(
抽象操作 WordCharacters 接收参数 rer(\b、\B、\w、\W 所认为的“单词字符”。调用时执行如下步骤:
抽象操作 AllCharacters 接收参数 rer(
抽象操作 MaybeSimpleCaseFolding 接收参数 rer(
抽象操作 CharacterComplement 接收参数 rer(
抽象操作 UnicodeMatchProperty 接收参数 rer(
实现必须支持
例如,Script_Extensions(scx(属性别名)有效,但 script_extensions 或 Scx 无效。
这些属性集合是 UTS18 RL1.2 要求的超集。
这些表中的拼写(包括大小写)与 Unicode Character Database 文件 PropertyAliases.txt
保持一致。该文件中的拼写是 保证稳定的。
|
|
规范 |
|---|---|
General_Category |
General_Category
|
gc |
|
Script |
Script
|
sc |
|
Script_Extensions |
Script_Extensions
|
scx |
|
|
规范 |
|---|---|
ASCII |
ASCII
|
ASCII_Hex_Digit |
ASCII_Hex_Digit
|
AHex |
|
Alphabetic |
Alphabetic
|
Alpha |
|
Any |
Any
|
Assigned |
Assigned
|
Bidi_Control |
Bidi_Control
|
Bidi_C |
|
Bidi_Mirrored |
Bidi_Mirrored
|
Bidi_M |
|
Case_Ignorable |
Case_Ignorable
|
CI |
|
Cased |
Cased
|
Changes_When_Casefolded |
Changes_When_Casefolded
|
CWCF |
|
Changes_When_Casemapped |
Changes_When_Casemapped
|
CWCM |
|
Changes_When_Lowercased |
Changes_When_Lowercased
|
CWL |
|
Changes_When_NFKC_Casefolded |
Changes_When_NFKC_Casefolded
|
CWKCF |
|
Changes_When_Titlecased |
Changes_When_Titlecased
|
CWT |
|
Changes_When_Uppercased |
Changes_When_Uppercased
|
CWU |
|
Dash |
Dash
|
Default_Ignorable_Code_Point |
Default_Ignorable_Code_Point
|
DI |
|
Deprecated |
Deprecated
|
Dep |
|
Diacritic |
Diacritic
|
Dia |
|
Emoji |
Emoji
|
Emoji_Component |
Emoji_Component
|
EComp |
|
Emoji_Modifier |
Emoji_Modifier
|
EMod |
|
Emoji_Modifier_Base |
Emoji_Modifier_Base
|
EBase |
|
Emoji_Presentation |
Emoji_Presentation
|
EPres |
|
Extended_Pictographic |
Extended_Pictographic
|
ExtPict |
|
Extender |
Extender
|
Ext |
|
Grapheme_Base |
Grapheme_Base
|
Gr_Base |
|
Grapheme_Extend |
Grapheme_Extend
|
Gr_Ext |
|
Hex_Digit |
Hex_Digit
|
Hex |
|
IDS_Binary_Operator |
IDS_Binary_Operator
|
IDSB |
|
IDS_Trinary_Operator |
IDS_Trinary_Operator
|
IDST |
|
ID_Continue |
ID_Continue
|
IDC |
|
ID_Start |
ID_Start
|
IDS |
|
Ideographic |
Ideographic
|
Ideo |
|
Join_Control |
Join_Control
|
Join_C |
|
Logical_Order_Exception |
Logical_Order_Exception
|
LOE |
|
Lowercase |
Lowercase
|
Lower |
|
Math |
Math
|
Noncharacter_Code_Point |
Noncharacter_Code_Point
|
NChar |
|
Pattern_Syntax |
Pattern_Syntax
|
Pat_Syn |
|
Pattern_White_Space |
Pattern_White_Space
|
Pat_WS |
|
Quotation_Mark |
Quotation_Mark
|
QMark |
|
Radical |
Radical
|
Regional_Indicator |
Regional_Indicator
|
RI |
|
Sentence_Terminal |
Sentence_Terminal
|
STerm |
|
Soft_Dotted |
Soft_Dotted
|
SD |
|
Terminal_Punctuation |
Terminal_Punctuation
|
Term |
|
Unified_Ideograph |
Unified_Ideograph
|
UIdeo |
|
Uppercase |
Uppercase
|
Upper |
|
Variation_Selector |
Variation_Selector
|
VS |
|
White_Space |
White_Space
|
space |
|
XID_Continue |
XID_Continue
|
XIDC |
|
XID_Start |
XID_Start
|
XIDS |
|
|
|---|
Basic_Emoji(基础表情符号) |
Emoji_Keycap_Sequence(表情符号按键序列) |
RGI_Emoji_Modifier_Sequence(RGI表情符号修饰符序列) |
RGI_Emoji_Flag_Sequence(RGI表情符号旗帜序列) |
RGI_Emoji_Tag_Sequence(RGI表情符号标签序列) |
RGI_Emoji_ZWJ_Sequence(RGI表情符号ZWJ序列) |
RGI_Emoji(RGI表情符号) |
抽象操作 UnicodeMatchPropertyValue 接收参数 p(
实现必须支持 PropertyValueAliases.txt
文件中列出的 Unicode 属性值和属性值别名。为保证互操作性,实现不得支持其他属性值或属性值别名。
例如,Xpeo 和 Old_Persian 是有效的
Script_Extensions 属性值,但 xpeo 和
Old Persian 无效。
此算法不同于 UAX44
中列出的符号值匹配规则:不会忽略大小写、Is 前缀。
抽象操作 RegExpCreate 接收参数 P(一个
抽象操作 RegExpAlloc 接收参数 newTarget(
抽象操作 RegExpInitialize 接收参数 obj(对象)、pattern(
抽象操作 ParsePattern 接收参数
patternText(Unicode码点序列)、u(布尔值)、v(布尔值),返回一个
本节在
调用时执行如下步骤:
RegExp
extends 子句的值。子类 super 调用,以便用必要的内部插槽来创建并初始化子类实例。
该函数被调用时执行以下步骤:
如果 pattern 是通过
RegExp
该函数返回 S 的一个副本,其中正则表达式
调用时执行以下步骤:
虽然名字相似,RegExp.escape 并不执行类似操作。前者用于将模式转义为字符串表示,后者用于将字符串转义为模式内部使用。
抽象操作 EncodeForRegExpEscape 接收参数 cp(码点),返回一个字符串。返回值即为匹配 cp 的模式
RegExp.prototype 的初始值为
该属性具有属性:{ [[Writable]]:
RegExp[%Symbol.species%] 是一个
此函数的
RegExp 原型方法通常使用其
RegExp 原型对象:
RegExp 原型对象自身没有
RegExp.prototype.constructor 的初始值为
该方法在 string 中搜索正则表达式的匹配项,并返回包含匹配结果的数组,若 string 不匹配则返回
调用时执行如下步骤:
RegExp.prototype.dotAll 是一个
RegExp.prototype.flags 是一个
抽象操作 RegExpHasFlag 接收参数 R(
RegExp.prototype.global 是一个
RegExp.prototype.hasIndices 是一个
RegExp.prototype.ignoreCase 是一个
该方法调用时执行如下步骤:
该方法的
该方法调用时执行如下步骤:
该方法的
RegExp.prototype.multiline 是一个
该方法调用时执行如下步骤:
该方法的
该方法调用时执行如下步骤:
该方法的
本 RegExp 对象的
RegExp.prototype.source 是一个
抽象操作 EscapeRegExpPattern 接收参数 P(字符串)和 F(字符串),返回一个字符串。调用时执行如下步骤:
/ 及所有 /// 后接 F 会被解析为 尽管名字类似,RegExp.escape 与 EscapeRegExpPattern
并不执行类似操作。前者用于将字符串转义为可在模式中使用的内容,后者用于将模式转义为可作为字符串表示。
该方法返回一个数组,数组中存储了将 string 转换为字符串后的子串。这些子串是通过从左到右搜索
/a*?/[Symbol.split]("ab")
的结果是 ["a", "b"],而 /a*/[Symbol.split]("ab") 的结果是
["","b"]。)
如果 string 是(或转换为)空字符串,结果取决于正则表达式是否能匹配空字符串。如果能,结果数组无元素;否则,结果数组含一个元素,即空字符串。
如果正则表达式含有捕获括号,则每次 separator 匹配时,括号捕获的结果(包括
/<(\/)?([^<>]+)>/[Symbol.split]("A<B>bold</B>and<CODE>coded</CODE>")
结果为数组
["A", undefined, "B", "bold", "/", "B", "and", undefined, "CODE", "coded", "/", "CODE", ""]
如果 limit 不为
该方法调用时执行如下步骤:
该方法的
该方法会忽略本 RegExp 对象的
RegExp.prototype.sticky 是一个
该方法调用时执行如下步骤:
返回的字符串具有
RegExp.prototype.unicode 是一个
RegExp.prototype.unicodeSets 是一个
抽象操作 RegExpExec 接收参数 R(对象)和 S(字符串),返回
如果未找到可调用的
抽象操作 RegExpBuiltinExec 接收参数 R(初始化后的 RegExp 实例)和 S(字符串),返回
抽象操作 AdvanceStringIndex 接收参数 S(字符串)、index(非负整数)、unicode(布尔值),返回一个整数。调用时执行如下步骤:
抽象操作 GetStringIndex 接收参数 S(字符串)和 codePointIndex(非负整数),返回一个非负整数。它将
S 作为 UTF-16 编码码点序列,根据
匹配记录(Match Record) 是一种
匹配记录的字段列于
| 字段名 | 值 | 含义 |
|---|---|---|
| [[StartIndex]] | 非负 |
匹配开始(包含)的字符串起始码元数。 |
| [[EndIndex]] | 一个 |
匹配结束(不含)的字符串起始码元数。 |
抽象操作 GetMatchString 接收参数 S(字符串)和 match(
抽象操作 GetMatchIndexPair 接收参数 S(字符串)和 match(
抽象操作 MakeMatchIndicesIndexPairArray 接收参数 S(字符串)、indices(
RegExp 实例是
在 ECMAScript 2015 之前,RegExp 实例被规范为拥有自身的数据属性 RegExp.prototype 的
RegExp 实例还具有以下属性:
RegExp 字符串迭代器是用于表示对某个特定字符串实例对象、针对某个特定 RegExp 实例对象进行迭代的对象。RegExp
字符串迭代器对象没有具名的
抽象操作 CreateRegExpStringIterator 接收参数 R(对象)、S(字符串)、global(布尔值)、fullUnicode(布尔值),返回一个对象。调用时执行如下步骤:
%RegExpStringIteratorPrototype% 对象:
该属性具有属性 { [[Writable]]:
| 内部插槽 | 类型 | 描述 |
|---|---|---|
| [[IteratingRegExp]] | 对象 | 用于迭代的正则表达式。 |
| [[IteratedString]] | 字符串 | 被迭代的字符串值。 |
| [[Global]] | 布尔值 | 指示 [[IteratingRegExp]] 是否为全局。 |
| [[Unicode]] | 布尔值 | 指示 [[IteratingRegExp]] 是否为 Unicode 模式。 |
| [[Done]] | 布尔值 | 指示迭代是否已完成。 |
数组是
Array
Array(…) 等价于使用相同参数的对象创建表达式 new Array(…)。
extends 子句的值。打算继承数组特殊行为的子类super 调用,以初始化作为Array.prototype 方法是泛型方法,不依赖于其 当调用该函数时,执行以下步骤:
Array
当调用该方法时,执行以下步骤:
当调用该函数时,执行以下步骤:
当调用该方法时,执行以下步骤:
Array.prototype 的值为
该属性具有属性 { [[Writable]]:
Array[%Symbol.species%] 是一个
该函数的
数组原型方法通常使用其
数组原型对象:
数组原型对象被指定为
该方法返回一个数组,包含该对象的数组元素后跟每个参数的数组元素。
调用时执行以下步骤:
该方法的
在步骤
该方法被设计为泛型;不要求其
抽象操作 IsConcatSpreadable 接收参数 O(一个
Array.prototype.constructor 的初始值为
end 参数是可选的。如果未提供,则使用
如果 target 为负数,则视为
调用该方法时执行以下步骤:
该方法被设计为泛型;它不要求其
该方法调用时执行以下步骤:
callback 应该是一个接受三个参数并返回可转换为布尔值的函数。every 会按升序对数组中实际存在的每个元素调用
callback 一次,直到遇到一个 callback 返回 every 会立即返回
every 返回
如果提供了 thisArg 参数,则每次调用 callback 时都会用作
callback 被调用时有三个参数:元素的值、元素的索引、被遍历的对象。
every 不会直接修改它所调用的对象,但该对象可能会被 callback 的调用修改。
every 处理的元素范围在第一次调用 callback 前就已确定。调用 every
之后添加到数组的元素不会被 callback 访问。如果数组中已存在的元素被修改,则传递给 callback 的值是在
every 访问该元素时的值;在 every
调用开始后被删除且尚未被访问的元素不会被访问。every 的行为类似于数学中的“全称量词”。特别地,对于空数组,它返回
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
start 参数是可选的。如果未提供,则使用
end 参数是可选的。如果未提供,则使用
如果 start 为负数,则视为
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
callback 应该是一个接受三个参数并返回可转换为布尔值的函数。filter 会按升序对数组中每个元素调用
callback 一次,并构造一个包含所有 callback 返回
如果提供了 thisArg 参数,则每次调用 callback 时都会用作
callback 被调用时有三个参数:元素的值、元素的索引、被遍历的对象。
filter 不会直接修改它所调用的对象,但该对象可能会被 callback 的调用修改。
filter 处理的元素范围在第一次调用 callback 前就已确定。调用 filter
之后添加到数组的元素不会被 callback 访问。如果数组中已存在的元素被修改,则传递给 callback 的值是在
filter 访问该元素时的值;在 filter 调用开始后被删除且尚未被访问的元素不会被访问。
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
该方法会按索引升序对数组的每个元素调用 predicate 一次,直到找到一个 predicate 返回可转换为
find
会立即返回该元素的值。否则,find 返回
更多信息见
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
该方法会按索引升序对数组的每个元素调用 predicate 一次,直到找到一个 predicate 返回可转换为
findIndex
会立即返回该元素的索引。否则,findIndex 返回 -1。
更多信息见
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
该方法会按索引降序对数组的每个元素调用 predicate 一次,直到找到一个 predicate 返回可转换为
findLast
会立即返回该元素的值。否则,findLast 返回
更多信息见
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
该方法会按索引降序对数组的每个元素调用 predicate 一次,直到找到一个 predicate 返回可转换为
findLastIndex
会立即返回该元素的索引。否则,findLastIndex 返回 -1。
更多信息见
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
抽象操作 FindViaPredicate 接收参数 O(一个对象)、len(一个非负
O 应为
predicate 应为一个函数。对数组的每个元素调用时,传递三个参数:元素的值、元素的索引和被遍历的对象。其返回值会被转换为布尔值。
thisArg 会作为每次调用 predicate 时的
该操作不会直接修改其调用的对象,但该对象可能会被 predicate 的调用修改。
处理的元素范围在首次调用 predicate 前(遍历开始前)就已确定。遍历后添加到数组的元素不会被 predicate
访问。如果数组中已存在的元素被修改,则传递给 predicate
的值为操作访问该元素时的值。在遍历开始后被删除且尚未被访问的元素依然会被访问,要么从原型获取,要么为
调用时执行以下步骤:
该方法调用时执行以下步骤:
抽象操作 FlattenIntoArray 接收参数
target(一个对象)、source(一个对象)、sourceLen(一个非负
该方法调用时执行以下步骤:
callback 应该是一个接受三个参数的函数。forEach 对数组中实际存在的每个元素按升序调用
callback 一次。callback 只会对数组中实际存在的元素调用,不会对数组中缺失的元素调用。
如果提供了 thisArg 参数,则每次调用 callback 时都会用作
callback 被调用时有三个参数:元素的值、元素的索引、被遍历的对象。
forEach 不会直接修改它所调用的对象,但该对象可能会被 callback 的调用修改。
forEach 处理的元素范围在第一次调用 callback 前就已确定。调用 forEach
之后添加到数组的元素不会被 callback 访问。如果数组中已存在的元素被修改,则传递给 callback 的值是在
forEach 访问该元素时的值;在 forEach 调用开始后被删除且尚未被访问的元素不会被访问。
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
该方法会按升序将 searchElement 与数组的元素进行比较,使用
可选的第二个参数 fromIndex 默认为
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
该方法有意与类似的 indexOf 方法有两点不同。第一,它使用
该方法使用
可选的第二个参数 fromIndex 默认为
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
该方法将数组的元素转换为字符串,然后用 separator 分隔这些字符串并连接起来。如果没有提供分隔符,则使用单个逗号作为分隔符。
调用时按照以下步骤执行:
该方法被设计为泛型;它不要求其
该方法调用时执行以下步骤:
该方法会按降序将 searchElement 与数组的元素比较,使用
可选的第二个参数 fromIndex 默认为数组长度减一(即搜索整个数组)。如果它大于等于数组长度,则会搜索整个数组。如果它小于
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
callback 应该是一个接受三个参数的函数。map 会按升序对数组中每个元素调用
callback 一次,并用结果构造一个新数组。callback
只会对数组中实际存在的元素调用,不会对数组中缺失的元素调用。
如果提供了 thisArg 参数,则每次调用 callback 时都会用作
callback 被调用时有三个参数:元素的值、元素的索引、被遍历的对象。
map 不会直接修改它所调用的对象,但该对象可能会被 callback 的调用修改。
map 处理的元素范围在第一次调用 callback 前就已确定。调用 map
之后添加到数组的元素不会被 callback 访问。如果数组中已存在的元素被修改,则传递给 callback 的值是在
map 访问该元素时的值;在 map 调用开始后被删除且尚未被访问的元素不会被访问。
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
该方法移除数组的最后一个元素并返回它。
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
该方法将参数按出现顺序追加到数组末尾。它返回数组的新长度。
该方法调用时执行以下步骤:
该方法的
该方法被设计为泛型;它不要求其
callback 应为一个接受四个参数的函数。reduce 会对数组中第一个元素之后的每个元素按升序以函数形式调用
callback 一次。
callback 被调用时带四个参数:previousValue(上次调用 callback
的值)、currentValue(当前元素的值)、currentIndex 和被遍历的对象。首次调用
callback 时,previousValue 和 currentValue
可能有两种情况。如果调用 reduce 时提供了 initialValue,则
previousValue 为 initialValue,currentValue
为数组的第一个值。如果没有提供 initialValue,则 previousValue
为数组的第一个值,currentValue 为第二个值。如果数组为空且未提供 initialValue,会抛出
reduce 不会直接修改其调用的对象,但对象可能会被 callback 的调用修改。
reduce 处理的元素范围在第一次调用 callback 前就已确定。调用 reduce
后添加到数组的元素不会被 callback 访问。如果数组中已存在的元素被修改,则传递给 callback 的值为
reduce 访问该元素时的值;在 reduce 调用开始后被删除且尚未被访问的元素不会被访问。
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
callback 应为一个接受四个参数的函数。reduceRight
会对数组中第一个元素之后的每个元素按降序以函数形式调用 callback 一次。
callback 被调用时带四个参数:previousValue(上次调用 callback
的值)、currentValue(当前元素的值)、currentIndex
和被遍历的对象。首次调用该函数时,previousValue 和 currentValue 可能有两种情况。如果调用
reduceRight 时提供了 initialValue,则 previousValue 为
initialValue,currentValue 为数组的最后一个值。如果没有提供
initialValue,则 previousValue 为数组的最后一个值,currentValue
为倒数第二个值。如果数组为空且未提供 initialValue,会抛出
reduceRight 不会直接修改其调用的对象,但对象可能会被 callback 的调用修改。
reduceRight 处理的元素范围在第一次调用 callback 前就已确定。调用
reduceRight 后添加到数组的元素不会被 callback 访问。如果数组中已存在的元素被
callback 修改,则传递给 callback 的值为 reduceRight
访问该元素时的值;在 reduceRight 调用开始后被删除且尚未被访问的元素不会被访问。
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
该方法重新排列数组元素,使其顺序颠倒。它返回反转后的数组。
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
该方法移除数组的第一个元素并返回它。
调用时按照以下步骤执行:
该方法被设计为泛型;它不要求其
该方法返回一个包含数组从元素 start 到(但不包括)元素 end 的元素的新数组(如果 end 是
调用时按照以下步骤执行:
第
该方法被设计为泛型;它不要求其
callback 应为一个接受三个参数并返回可转换为布尔值的函数。some 会对数组中实际存在的每个元素按升序调用
callback,直到找到一个 callback 返回 some 会立即返回 some
返回
如果提供了 thisArg 参数,则每次调用 callback 时都会用作
callback 被调用时有三个参数:元素的值、元素的索引、被遍历的对象。
some 不会直接修改其调用的对象,但该对象可能会被 callback 的调用修改。
some 处理的元素范围在第一次调用 callback 前就已确定。调用 some
后添加到数组的元素不会被 callback 访问。如果数组中已存在的元素被修改,则传递给 callback 的值是在
some 访问该元素时的值;在 some
调用开始后被删除且尚未被访问的元素不会被访问。some 类似于数学中的“存在”量词。特别地,对于空数组,它返回
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
该方法对数组的元素进行排序。如果 comparator 不为
调用时按照以下步骤执行:
由于不存在的属性值总是大于
该方法被设计为泛型;它不要求其
抽象操作 SortIndexedProperties 接收参数 obj(一个对象)、len(一个非负
排序顺序(sort order)指的是上述算法中第
除非
此处记号
抽象闭包或函数 comparator 对于值集合 S 来说,如果对集合 S 中所有可能的值
a、b、c(可能相同)均满足以下要求,则称其为 一致性比较器。记号
上述条件是保证 comparator 将集合 S 划分为等价类并且这些等价类是全序所必需且充分的条件。
抽象操作 CompareArrayElements 接收参数 x(一个
该方法从整数索引 start 开始,删除数组中的 deleteCount 个元素,并用 items 的元素替换它们。它返回一个包含被删除元素(如有)的数组。
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 规范实现此方法。如果 ECMAScript 实现不包含 ECMA-402 API,则使用下面对该方法的规范。
ECMA-402 第一版未包含该方法的替代规范。
此方法的可选参数含义在 ECMA-402 规范中定义;不包含 ECMA-402 支持的实现不得将这些参数位置用于其他用途。
该方法调用时执行以下步骤:
该方法使用元素各自的 toLocaleString
方法将数组元素转换为字符串,然后用实现定义的、区分区域设置的分隔符字符串把这些字符串连接起来。此方法类似于 toString,但目的是生成符合
该方法被设计为泛型;它不要求其
该方法调用时执行以下步骤:
该方法调用时执行以下步骤:
该方法调用时执行以下步骤:
该方法调用时执行以下步骤:
该方法被设计为泛型;它不要求其
该方法将参数添加到数组的开头,其在数组中的顺序与参数列表中的顺序相同。
该方法调用时执行以下步骤:
该方法的
该方法被设计为泛型;它不要求其
该方法调用时执行以下步骤:
该方法调用时执行以下步骤:
该属性具有属性 { [[Writable]]:
该对象的自有属性名是在 ECMAScript 2015 规范之前未作为 Array.prototype 标准属性包含的属性名。这些名称在
with 语句绑定时会被忽略,以保持现有代码的行为,这些代码可能在外部作用域中使用其中的某个名称作为绑定,而该作用域被
with 语句(其绑定对象为数组)所遮蔽。
数组实例是
数组实例有一个
Array 实例的
数组迭代器是一个表示对某个特定数组实例对象的特定迭代的对象。数组迭代器对象没有命名的
抽象操作 CreateArrayIterator 接收参数 array(一个对象)和
kind(
%ArrayIteratorPrototype% 对象:
该属性具有属性 { [[Writable]]:
TypedArray 展示了一个底层二进制数据缓冲区(
|
|
元素类型 | 元素大小 | 转换操作 | 描述 |
|---|---|---|---|---|
|
Int8Array %Int8Array% |
|
1 |
|
8 位二进制补码有符号 |
|
Uint8Array %Uint8Array% |
|
1 |
|
8 位无符号 |
|
Uint8ClampedArray %Uint8ClampedArray% |
|
1 |
|
8 位无符号 |
|
Int16Array %Int16Array% |
|
2 |
|
16 位二进制补码有符号 |
|
Uint16Array %Uint16Array% |
|
2 |
|
16 位无符号 |
|
Int32Array %Int32Array% |
|
4 |
|
32 位二进制补码有符号 |
|
Uint32Array %Uint32Array% |
|
4 |
|
32 位无符号 |
|
BigInt64Array %BigInt64Array% |
|
8 |
|
64 位二进制补码有符号 |
|
BigUint64Array %BigUint64Array% |
|
8 |
|
64 位无符号 |
|
Float16Array %Float16Array% |
|
2 | 16 位 IEEE 浮点数 | |
|
Float32Array %Float32Array% |
|
4 | 32 位 IEEE 浮点数 | |
|
Float64Array %Float64Array% |
|
8 | 64 位 IEEE 浮点数 |
在下述定义中,对 TypedArray 的引用应替换为上表中相应的
%TypedArray% 内建对象:
super 调用。
该函数被调用时执行以下步骤:
该函数的
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
.prototype
的初始值为
该属性具有属性 { [[Writable]]:
[%Symbol.species%]
是一个
该函数的
%TypedArray% 原型对象:
.prototype.buffer
是一个
.prototype.byteLength
是一个
.prototype.byteOffset
是一个
.prototype.constructor
的初始值为
该方法的参数解释和用法与 Array.prototype.copyWithin 相同。
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法的参数解释和用法与 Array.prototype.every 相同。
该方法被调用时执行以下步骤:
该方法不是泛型的。
该方法的参数解释和用法与 Array.prototype.fill 相同。
该方法被调用时执行以下步骤:
该方法的参数解释和用法与 Array.prototype.filter 相同。
该方法被调用时执行以下步骤:
该方法不是泛型的。
该方法的参数解释和用法与 Array.prototype.find 相同。
该方法被调用时执行以下步骤:
该方法不是泛型的。
该方法的参数解释和用法与 Array.prototype.findIndex 相同。
该方法被调用时执行以下步骤:
该方法不是泛型的。
该方法的参数解释和用法与 Array.prototype.findLast 相同。
该方法被调用时执行以下步骤:
该方法不是泛型的。
该方法的参数解释和用法与 Array.prototype.findLastIndex 相同。
该方法被调用时执行以下步骤:
该方法不是泛型的。
该方法的参数解释和用法与 Array.prototype.forEach 相同。
该方法被调用时执行以下步骤:
该方法不是泛型的。
该方法的参数解释和用法与 Array.prototype.includes 相同。
该方法被调用时执行以下步骤:
该方法不是泛型的。
该方法的参数解释和用法与 Array.prototype.indexOf 相同。
该方法被调用时执行以下步骤:
该方法不是泛型的。
该方法的参数解释和用法与 Array.prototype.join 相同。
该方法被调用时执行以下步骤:
该方法不是泛型的。
该方法被调用时执行以下步骤:
该方法的参数解释和用法与 Array.prototype.lastIndexOf 相同。
该方法被调用时执行以下步骤:
该方法不是泛型的。
.prototype.length
是一个
该函数不是泛型的。
该方法的参数解释和用法与 Array.prototype.map 相同。
该方法被调用时执行以下步骤:
该方法不是泛型的。
该方法的参数解释和用法与 Array.prototype.reduce 相同。
该方法被调用时执行以下步骤:
该方法不是泛型的。
该方法的参数解释和用法与 Array.prototype.reduceRight 相同。
该方法被调用时执行以下步骤:
该方法不是泛型的。
该方法的参数解释和用法与 Array.prototype.reverse 相同。
该方法被调用时执行以下步骤:
该方法不是泛型的。
该方法会在此 TypedArray 中设置多个值,从 source 读取值。具体细节取决于 source 的类型。可选的 offset 值表示在此 TypedArray 中写入值的第一个元素索引。如果省略,假定为 0。
该方法被调用时执行以下步骤:
该方法不是泛型的。
抽象操作 SetTypedArrayFromTypedArray 接收参数 target(一个
抽象操作 SetTypedArrayFromArrayLike 接收参数 target(一个
该方法的参数解释和用法与 Array.prototype.slice 相同。
该方法被调用时执行以下步骤:
该方法不是泛型的。
该方法的参数解释和用法与 Array.prototype.some 相同。
该方法被调用时执行以下步骤:
该方法不是泛型的。
这是一个不同的方法,除下述说明外,其实现要求与 Array.prototype.sort 相同。该方法的实现可以利用
该方法不是泛型的。
该方法被调用时执行以下步骤:
由于
该方法返回一个新的 TypedArray,其元素类型与此 TypedArray 的元素类型相同,ArrayBuffer 也与此 TypedArray 相同,引用 start(包含)到 end(不包含)区间内的元素。如果 start 或 end 为负数,则它表示从数组末尾开始的索引,而不是从头开始。
该方法被调用时执行以下步骤:
该方法不是泛型的。
这是一个不同的方法,其实现算法与 Array.prototype.toLocaleString 相同,只是用
该方法不是泛型的。调用算法前会用
如果 ECMAScript 实现包含 ECMA-402 国际化 API,则该方法基于 ECMA-402 规范中的
Array.prototype.toLocaleString 算法。
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
.prototype[%Symbol.toStringTag%]
是一个
该属性具有属性 { [[Enumerable]]:
该函数的
抽象操作 TypedArraySpeciesCreate 接收参数 exemplar(一个
抽象操作 TypedArrayCreateFromConstructor 接收参数 constructor(一个
抽象操作 TypedArrayCreateSameType 接收参数 exemplar(一个
抽象操作 ValidateTypedArray 接收参数 O(一个
抽象操作 TypedArrayElementSize 接收参数 O(一个
抽象操作 TypedArrayElementType 接收参数 O(一个
抽象操作 CompareTypedArrayElements 接收参数 x(一个 Number 或 BigInt)、y(一个 Number 或
BigInt)、comparator(一个
每个 TypedArray
extends 子句的值。想要继承指定 TypedArray 行为的子类 super
调用,以用必要的内部状态创建和初始化子类实例,以支持 .prototype
内建方法。
每个 TypedArray
"%TypedArray.prototype%"。抽象操作 AllocateTypedArray 接收参数 constructorName(一个字符串,为
抽象操作 InitializeTypedArrayFromTypedArray 接收参数 O(一个
每个 TypedArray
TypedArray.BYTES_PER_ELEMENT 的值为
该属性具有属性 { [[Writable]]:
TypedArray.prototype 的初始值为对应的 TypedArray 原型内建对象(
该属性具有属性 { [[Writable]]:
每个 TypedArray 原型对象:
TypedArray.prototype.BYTES_PER_ELEMENT 的值为
该属性具有属性 { [[Writable]]:
TypedArray 实例是
Map 是一种键/值对集合,其中键和值都可以是任意的
Map 必须通过哈希表或其他机制实现,这些机制平均而言可以提供次线性的元素访问时间。本规范中所用的数据结构仅用于描述 Map 所需的可观察语义,而不是可行的实现模型。
Map
extends 子句的值。想要继承指定 Map 行为的子类 super 调用,以用必要的内部状态创建和初始化子类实例,以支持 Map.prototype 内建方法。
该函数被调用时执行以下步骤:
如果参数 iterable 存在,期望它是一个实现了
抽象操作 AddEntriesFromIterable 接收参数 target(一个对象)、iterable(
参数 iterable 期望是一个实现了
Map
callback 应该是一个接受两个参数的函数。groupBy 会按照升序对 items
中的每个元素调用 callback 一次,并构造一个新的 Map。每个 callback 返回的值会作为 Map
的键。对于每个这样的键,结果 Map 有一个键为该键、值为包含所有 callback 返回该键的元素的数组的条目。
callback 的两个参数分别是元素的值和索引。
groupBy 的返回值是一个 Map。
该函数被调用时执行以下步骤:
Map.prototype 的初始值为
该属性具有属性 { [[Writable]]:
Map[%Symbol.species%] 是一个
该函数的
创建派生集合对象的方法应当调用
Map 原型对象:
该方法被调用时执行以下步骤:
Map.prototype.constructor 的初始值为
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
callback 应该是一个接受三个参数的函数。forEach 会按照键的插入顺序对 Map 中每个键/值对调用
callback 一次。只有实际存在的 Map 键才会被调用 callback;已被删除的键不会被调用。
如果提供了 thisArg 参数,则该参数会作为每次调用 callback 时的
callback 的三个参数分别是项的值、项的键,以及被遍历的 Map。
forEach 本身不会直接修改被调用对象,但该对象可能会被 callback 的调用修改。map 的 [[MapData]] 的每个条目只会被访问一次。在 forEach
开始后添加的新键会被访问。如果某个键被访问后被删除并在 forEach 完成前重新添加,则该键会被再次访问。在
forEach 开始后但被访问前被删除的键不会被访问,除非该键在 forEach 完成前被再次添加。
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
Map.prototype.size 是一个
该方法被调用时执行以下步骤:
该属性具有属性 { [[Writable]]:
Map 实例是
Map
迭代器 是一个表示对某个特定 Map 实例对象的特定遍历的对象。Map 迭代器对象没有具名的
抽象操作 CreateMapIterator 接收参数 map(一个
%MapIteratorPrototype% 对象:
该属性具有特性 { [[Writable]]:
Set 对象是
Set 对象必须通过哈希表或其他机制实现,这些机制在平均情况下能提供次线性的元素访问时间。本规范中所用的数据结构仅用于描述 Set 对象所需的可观察语义,而非实际的实现模型。
Set 记录是一个
Set 记录具有
抽象操作 GetSetRecord 接收参数 obj(一个
抽象操作 SetDataHas 接收参数 setData(一个
抽象操作 SetDataIndex 接收参数 setData(一个
抽象操作 SetDataSize 接收参数 setData(一个
Set
extends 子句的值。想要继承指定 Set 行为的子类 super 调用,以用必要的内部状态创建和初始化子类实例,以支持 Set.prototype 内建方法。
该函数被调用时执行以下步骤:
Set
Set.prototype 的初始值为
该属性具有属性 { [[Writable]]:
Set[%Symbol.species%] 是一个
该函数的
创建派生集合对象的方法应当调用
Set 原型对象:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
Set.prototype.constructor 的初始值为
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
对于遍历目的,Set 类似于每个条目的键和值都相同的 Map。
该方法被调用时执行以下步骤:
callback 应该是一个接受三个参数的函数。forEach 会按照值插入顺序对 Set 对象中每个存在的值调用
callback 一次。只有实际存在的 Set 值才会被调用 callback;已被删除的键不会被调用。
如果提供了 thisArg 参数,则其会用作每次调用 callback 时的
callback 会被传入三个参数:前两个参数是 Set 中包含的同一个值,第三个参数是正在遍历的 Set 对象。
回调函数采用三个参数是为了与 Map 和 Array 的 forEach 方法的回调一致。对于 Set,每个元素既视为键又视为值。
forEach 本身不会直接修改被调用对象,但该对象可能会被 callback 的调用修改。
每个值通常只会被访问一次。不过,如果某个值被访问后被删除并在 forEach 完成前重新添加,则该值会被再次访问。在
forEach 开始后但被访问前被删除的值不会被访问,除非该值在 forEach 完成前被再次添加。在
forEach 开始后添加的新值会被访问。
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
对于遍历目的,Set 类似于每个条目的键和值都相同的 Map。
Set.prototype.size 是一个
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该属性具有属性 { [[Writable]]:
Set 实例是
Set
迭代器 是一个
抽象操作 CreateSetIterator 接收参数 set(一个
%SetIteratorPrototype% 对象:
该属性具有属性 { [[Writable]]:
WeakMap 是键/值对的集合,其中键是对象和/或符号,值可以是任意的
实现可能会对 WeakMap 的某个键/值对变得不可访问与被移除之间施加任意的延迟。如果这个延迟对 ECMAScript 程序是可观察的,则会带来不确定性,影响程序执行。因此,ECMAScript 的实现不得提供任何无需观察者持有该键即可观察 WeakMap 键的手段。
WeakMap 必须通过哈希表或其他机制实现,这些机制在平均情况下能提供次线性的键/值对访问时间。本规范中所用的数据结构仅用于描述 WeakMap 所需的可观察语义,而非实际的实现模型。
WeakMap 和 WeakSet 旨在为对象或符号动态关联状态,且如果没有 WeakMap 或 WeakSet 实例,该对象或符号变得不可访问并被垃圾回收机制回收时,不会“泄漏”内存资源。可以通过将 WeakMap 或 WeakSet 实例反向映射到每个对象/符号实现这一特性。或者,每个 WeakMap 或 WeakSet 实例可以内部存储其键和值数据,但这种方法需要 WeakMap/WeakSet 实现与垃圾回收器协作。下列参考文献介绍了对 WeakMap 和 WeakSet 实现可能有用的机制:
Barry Hayes. 1997. Ephemerons: a new finalization mechanism. 载于 Proceedings of the 12th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications (OOPSLA '97), A. Michael Berman (编辑). ACM, New York, NY, USA, 176-183, http://doi.acm.org/10.1145/263698.263733.
Alexandra Barros, Roberto Ierusalimschy, Eliminating Cycles in Weak Tables. Journal of Universal Computer Science - J.UCS, vol. 14, no. 21, pp. 3481-3497, 2008, http://www.jucs.org/jucs_14_21/eliminating_cycles_in_weak
WeakMap
extends 子句的值。想要继承指定 WeakMap 行为的子类 super 调用,以用必要的内部状态创建和初始化子类实例,以支持 WeakMap.prototype 内建方法。
该函数被调用时执行以下步骤:
如果参数 iterable 存在,期望它是一个实现了
WeakMap
WeakMap.prototype 的初始值为
该属性具有属性 { [[Writable]]:
WeakMap 原型对象:
WeakMap.prototype.constructor 的初始值为
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该属性具有属性 { [[Writable]]:
WeakMap 实例是
WeakSet 是对象和/或符号的集合。在 WeakSet 的集合中,每个不同的对象或符号只能出现一次。WeakSet
可以用来查询是否包含某个特定值,但没有机制用于枚举它所持有的所有值。在某些情况下,非
实现可能会对 WeakSet 所包含的某个值变得不可访问与被移除之间施加任意的延迟。如果这个延迟对 ECMAScript 程序是可观察的,则会带来不确定性,影响程序执行。因此,ECMAScript 的实现不得提供任何无需观察者持有该值即可确定 WeakSet 是否包含该值的手段。
WeakSet 必须通过哈希表或其他机制实现,这些机制在平均情况下能提供次线性的元素访问时间。本规范中所用的数据结构仅用于描述 WeakSet 所需的可观察语义,而非实际的实现模型。
参见
WeakSet
extends 子句的值。想要继承指定 WeakSet 行为的子类 super 调用,以用必要的内部状态创建和初始化子类实例,以支持 WeakSet.prototype 内建方法。
该函数被调用时执行以下步骤:
WeakSet
WeakSet.prototype 的初始值为
该属性具有属性 { [[Writable]]:
WeakSet 原型对象:
该方法被调用时执行以下步骤:
WeakSet.prototype.constructor 的初始值为
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该属性具有属性 { [[Writable]]:
WeakSet 实例是
抽象操作 CanonicalizeKeyedCollectionKey 接收参数 key(一个
本节、
读-改-写修改函数
是一个数学函数,被表示为一个抽象闭包,接收两个
为帮助验证读-改-写修改函数的算法步骤是否构成了纯数学函数,推荐以下编辑约定:
固定长度 ArrayBuffer 是指创建后字节长度不可更改的 ArrayBuffer。
可调整长度 ArrayBuffer 是指其字节长度可以在创建后通过调用
所创建的 ArrayBuffer 对象的种类取决于传递给
抽象操作 AllocateArrayBuffer 接收参数 constructor(一个
抽象操作 ArrayBufferByteLength 接收参数 arrayBuffer(一个 ArrayBuffer 或 SharedArrayBuffer)和
order(
抽象操作 ArrayBufferCopyAndDetach 接收参数 arrayBuffer(一个
realloc。
抽象操作 IsDetachedBuffer 接收参数 arrayBuffer(一个 ArrayBuffer 或 SharedArrayBuffer),返回一个布尔值。调用时执行以下步骤:
抽象操作 DetachArrayBuffer 接收参数 arrayBuffer(一个 ArrayBuffer)和可选参数
key(任意值),返回
分离 ArrayBuffer 实例会将用作其底层存储的
抽象操作 CloneArrayBuffer 接收参数 srcBuffer(一个 ArrayBuffer 或
SharedArrayBuffer)、srcByteOffset(非负
抽象操作 GetArrayBufferMaxByteLengthOption 接收参数 options(一个
HostResizeArrayBuffer 的实现必须符合以下要求:
HostResizeArrayBuffer 的默认实现是返回
抽象操作 IsFixedLengthArrayBuffer 接收参数 arrayBuffer(一个 ArrayBuffer 或 SharedArrayBuffer),返回布尔值。调用时执行以下步骤:
抽象操作 IsUnsignedElementType 接收参数 type(一个
抽象操作 IsUnclampedIntegerElementType 接收参数 type(一个
抽象操作 IsBigIntElementType 接收参数 type(一个
抽象操作 IsNoTearConfiguration 接收参数 type(一个
抽象操作 RawBytesToNumeric 接收参数 type(一个
抽象操作 GetRawBytesFromSharedBlock 接收参数 block(一个
抽象操作 GetValueFromBuffer 接收参数 arrayBuffer(一个 ArrayBuffer 或
SharedArrayBuffer)、byteIndex(非负
抽象操作 NumericToRawBytes 接收参数 type(一个
抽象操作 SetValueInBuffer 接收参数 arrayBuffer(一个 ArrayBuffer 或
SharedArrayBuffer)、byteIndex(非负
抽象操作 GetModifySetValueInBuffer 接收参数 arrayBuffer(一个 ArrayBuffer 或
SharedArrayBuffer)、byteIndex(非负
ArrayBuffer
extends 子句的值。想要继承指定 ArrayBuffer 行为的子类 super 调用,以用必要的内部状态创建和初始化子类实例,以支持 ArrayBuffer.prototype 内建方法。
该函数被调用时执行以下步骤:
ArrayBuffer
该函数被调用时执行以下步骤:
ArrayBuffer.prototype 的初始值为
该属性具有属性 { [[Writable]]:
ArrayBuffer[%Symbol.species%] 是一个
此函数的
ArrayBuffer 原型对象:
ArrayBuffer.prototype.byteLength 是一个
ArrayBuffer.prototype.constructor 的初始值为
ArrayBuffer.prototype.detached 是一个
ArrayBuffer.prototype.maxByteLength 是一个
ArrayBuffer.prototype.resizable 是一个
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该属性具有属性 { [[Writable]]:
ArrayBuffer 实例继承自
如果 ArrayBuffer 实例的 [[ArrayBufferData]] 为
如果 ArrayBuffer 实例的 [[ArrayBufferDetachKey]] 被设置为非
以下是针对使用
建议程序尽可能在其部署环境中进行测试。不同硬件设备的物理内存容量差异巨大。同样,虚拟内存子系统在不同的硬件设备和操作系统间也差异很大。在 64 位桌面 Web 浏览器上无内存溢出错误运行的应用程序,可能会在 32 位移动 Web 浏览器上耗尽内存。
为
请注意,为特定最大值成功构造一个
以下是针对实现
如果
如果
固定长度 SharedArrayBuffer 是指创建后字节长度不可更改的 SharedArrayBuffer。
可增长 SharedArrayBuffer 是指其字节长度可以在创建后通过调用
所创建的 SharedArrayBuffer 对象的种类取决于传递给
抽象操作 AllocateSharedArrayBuffer 接收参数 constructor(一个
抽象操作 IsSharedArrayBuffer 接收参数 obj(一个 ArrayBuffer 或 SharedArrayBuffer),返回布尔值。用于检测对象是 ArrayBuffer、SharedArrayBuffer 还是二者的子类型。调用时执行以下步骤:
HostGrowSharedArrayBuffer 的实现必须符合以下要求:
SharedArrayBuffer.prototype.grow 的竞争调用不会“丢失”,即不会悄然无效。
上述第二点故意没有规定如何或何时读取 buffer 的当前字节长度。由于字节长度必须通过底层硬件上的原子读-改-写操作进行更新,采用 load-link/store-conditional 或 load-exclusive/store-exclusive 指令对的架构可能希望将配对指令保持在指令流中较近的位置。因此,SharedArrayBuffer.prototype.grow 自身不会在调用 HostGrowSharedArrayBuffer 前对 newByteLength 进行边界检查,也不要求何时读取当前字节长度。
这与
HostGrowSharedArrayBuffer 的默认实现是返回
SharedArrayBuffer
extends 子句的值。想要继承指定 SharedArrayBuffer 行为的子类 super
调用,以用必要的内部状态创建和初始化子类实例,以支持 SharedArrayBuffer.prototype 内建方法。
如果
与 ArrayBuffer 不同,SharedArrayBuffer 不会被分离,其内部 [[ArrayBufferData]] 槽也永远不会是
该函数被调用时执行以下步骤:
SharedArrayBuffer
SharedArrayBuffer.prototype 的初始值为
该属性具有属性 { [[Writable]]:
SharedArrayBuffer[%Symbol.species%] 是一个
此函数的
SharedArrayBuffer 原型对象:
SharedArrayBuffer.prototype.byteLength 是一个
SharedArrayBuffer.prototype.constructor 的初始值为
该方法被调用时执行以下步骤:
比较-交换操作更新长度出现伪失败是不允许的。如果新长度的边界检查通过且实现未耗尽内存,则总会在
对 SharedArrayBuffer.prototype.grow 的并发调用是全序的。例如,考虑两个竞争调用:sab.grow(10) 和
sab.grow(20)。这两个调用中的一个保证会赢得竞争。即使 sab.grow(20)
先发生,sab.grow(10) 也绝不会导致 sab 变小;此时它会抛出 RangeError。
SharedArrayBuffer.prototype.growable 是一个
SharedArrayBuffer.prototype.maxByteLength 是一个
该方法被调用时执行以下步骤:
该属性具有属性 { [[Writable]]:
SharedArrayBuffer 实例继承自
SharedArrayBuffer 实例与 ArrayBuffer 实例不同,永远不会被分离。
以下是针对使用
建议程序尽可能在其部署环境中进行测试。不同硬件设备的物理内存容量差异巨大。同样,虚拟内存子系统在不同的硬件设备和操作系统间也差异很大。在 64 位桌面 Web 浏览器上无内存溢出错误运行的应用程序,可能会在 32 位移动 Web 浏览器上耗尽内存。
为
请注意,为特定最大值成功构造一个
并非所有对 u8[idx])的长度读取不是同步的。一般来说,在缺少显式同步的情况下,一次属性访问在范围内并不意味着同一 length 和 byteLength
getter、
以下是针对实现
建议
因为 grow 操作可能与可增长 SharedArrayBuffer 的内存访问并行发生,
扩容后新增的内存必须从创建时起就表现为全零,包括对并发访问也是如此。这可以通过按需零填充的虚拟内存页实现,或通过手动清零时的细致同步实现。
对可增长 SharedArrayBuffer 的
实际上,在没有虚拟内存的
带 Buffer 见证记录的
DataView 是一个
带 Buffer 见证记录的 DataView 拥有
| 字段名 | 值 | 含义 |
|---|---|---|
| [[Object]] | 一个 DataView | 被加载缓冲区字节长度的 DataView 对象。 |
| [[CachedBufferByteLength]] |
一个非负 |
创建该 |
抽象操作 MakeDataViewWithBufferWitnessRecord 接收参数 obj(一个 DataView)和
order(
抽象操作 GetViewByteLength 接收参数 viewRecord(一个
抽象操作 IsViewOutOfBounds 接收参数 viewRecord(一个
抽象操作 GetViewValue 接收参数 view(一个
抽象操作 SetViewValue 接收参数 view(一个
DataView
extends 子句的值。想要继承指定 DataView 行为的子类 super 调用,以用必要的内部状态创建和初始化子类实例,以支持 DataView.prototype 内建方法。
该函数被调用时执行以下步骤:
DataView
DataView.prototype 的初始值为
该属性具有属性 { [[Writable]]:
DataView 原型对象:
DataView.prototype.buffer 是一个
DataView.prototype.byteLength 是一个
DataView.prototype.byteOffset 是一个
DataView.prototype.constructor 的初始值为
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该属性具有属性 { [[Writable]]:
DataView 实例是
[[DataView]] 内部槽的值在本规范中不会被使用。该内部槽的简单存在用来标识通过 DataView
Atomics 对象:
new 运算符作为 Atomics 对象提供能在共享内存数组单元上以不可分割(原子)方式操作的函数,以及允许
关于 ECMAScript 中共享内存的编程和实现的参考指南,请参见
Waiter 记录 是一个 Atomics.wait 或 Atomics.waitAsync 调用。
Waiter 记录的字段见
| 字段名 | 值 | 含义 |
|---|---|---|
| [[AgentSignifier]] |
一个 |
调用 Atomics.wait 或 Atomics.waitAsync 的 |
| [[PromiseCapability]] |
一个 |
如果表示一次 Atomics.waitAsync 调用,则为结果 Promise,否则为
|
| [[TimeoutTime]] |
非负 |
最早可能触发超时的时间;使用 |
| [[Result]] |
|
调用的返回值。 |
WaiterList 记录 用于解释通过 Atomics.wait、Atomics.waitAsync 和 Atomics.notify 的等待与通知。
WaiterList 记录的字段见
| 字段名 | 值 | 含义 |
|---|---|---|
| [[Waiters]] |
一个 |
等待在与该 WaiterList 相关联的位置上的 Atomics.wait 或
Atomics.waitAsync 调用。
|
| [[MostRecentLeaveEvent]] |
一个 |
最近一次离开其 |
一个 WaiterList 中可以有多个
每个 WaiterList 记录有一个 临界区,用于在求值期间控制对该
WaiterList 记录的独占访问。每次只有一个
抽象操作 ValidateIntegerTypedArray 接收参数 typedArray(一个
抽象操作 ValidateAtomicAccess 接收参数 taRecord(一个
抽象操作 ValidateAtomicAccessOnIntegerTypedArray 接收参数 typedArray(一个
抽象操作 RevalidateAtomicAccess 接收参数 typedArray(一个
抽象操作 GetWaiterList 接收参数 block(一个
抽象操作 EnterCriticalSection 接收参数 WL(一个
当某个
抽象操作 LeaveCriticalSection 接收参数 WL(一个
抽象操作 AddWaiter 接收参数 WL(一个
抽象操作 RemoveWaiter 接收参数 WL(一个
抽象操作 RemoveWaiters 接收参数 WL(一个
抽象操作 SuspendThisAgent 接收参数 WL(一个
Atomics.notify 调用)而被唤醒。
抽象操作 NotifyWaiter 接收参数 WL(一个
抽象操作 EnqueueResolveInAgentJob 接收参数 agentSignifier(一个
抽象操作 DoWait 接收参数 mode(
additionalTimeout 允许实现根据需要填充超时时间,比如降低功耗或粗化定时器分辨率以缓解计时攻击。该值在 DoWait 的不同调用之间可能不同。
抽象操作 EnqueueAtomicsWaitAsyncTimeoutJob 接收参数 WL(一个
抽象操作 AtomicCompareExchangeInSharedBlock 接收参数 block(一个
抽象操作 AtomicReadModifyWrite 接收参数 typedArray(一个
抽象操作 ByteListBitwiseOp 接收参数 op(&、^ 或
|)、xBytes(一个
&,则^,则|。
抽象操作 ByteListEqual 接收参数 xBytes(一个
该函数被调用时执行以下步骤:
该函数被调用时执行以下步骤:
&,
xBytes, yBytes)。
该函数被调用时执行以下步骤:
该函数被调用时执行以下步骤:
该函数被调用时执行以下步骤:
该函数是一个优化原语。直观理解是:如果对一个字节数为 n
的数据执行原子操作(compareExchange、load、store、add、sub、and、or、xor
或 exchange)时,Atomics.isLockFree(n) 会返回
Atomics.isLockFree(4) 总是返回
无论该函数返回何值,所有原子操作都保证是原子的。例如,永远不会在操作中间有可见操作发生(如“撕裂”)。
该函数被调用时执行以下步骤:
该函数被调用时执行以下步骤:
|,
xBytes, yBytes)。
该函数被调用时执行以下步骤:
该函数被调用时执行以下步骤:
该函数会将
被调用时执行以下步骤:
该函数返回一个 Promise,当调用的
被调用时执行以下步骤:
该函数会通知一些在等待队列中休眠的
被调用时执行以下步骤:
该函数被调用时执行以下步骤:
^,
xBytes, yBytes)。
该属性具有属性 { [[Writable]]:
JSON 对象:
parse 和 stringify,用于解析和构造 JSON 文本。new 运算符作为 JSON 数据交换格式在 ECMA-404 中定义。本规范中使用的 JSON 交换格式与 ECMA-404 描述的完全一致。JSON.parse 和
JSON.stringify 的符合实现,必须支持 ECMA-404 规范中描述的精确交换格式,不得对格式做任何删减或扩展。
该函数用于解析 JSON 文本(JSON 格式的字符串),并生成一个
可选参数 reviver 是一个带有两个参数 key 和 value 的函数。它可以过滤和转换结果。该函数会对解析产生的每一个
key/value 对调用,其返回值会替代原始值。如果返回原值,则结构不变。如果返回
该函数的
抽象操作 ParseJSON 接收参数 text(一个字符串),返回
符合要求的 JSON.parse 实现不允许扩展 JSON 语法。如果实现希望支持修改或扩展的 JSON 交换格式,必须通过另一个解析函数实现。
有效的 JSON 文本是 ECMAScript
然而,由于
在对象内存在重复名称字符串时,词法上靠前的同名键对应的值会被后面的覆盖。
抽象操作 InternalizeJSONProperty 接收参数
holder(对象)、name(字符串)、reviver(
本算法有意不在 [[Delete]] 或
调用时执行以下步骤:
该函数返回一个表示
被调用时执行以下步骤:
该函数的
JSON 结构可以任意嵌套,但必须无环。如果 value 是或包含循环结构,则该函数必须抛出
a = [];
a[0] = a;
my_text = JSON.stringify(a); // 这里必须抛出 TypeError。
符号原始值的序列化规则如下:
字符串值用引号(")括起来。" 和 \ 需用 \ 转义。控制字符替换为
\uHHHH 或更短的
\b(退格)、\f(换页)、\n(换行)、\r(回车)、\t(制表)。
没有 JSON 表示的值(如
对象以 U+007B(左大括号)开头,后接零个或多个属性(用 U+002C 逗号分隔),以 U+007D(右大括号)结尾。属性为带引号的字符串表示属性名、U+003A(冒号)和序列化后的值。数组以 U+005B(左中括号)开头,后接零个或多个值(用 U+002C 逗号分隔),以 U+005D(右中括号)结尾。
JSON 序列化记录 是一个
JSON 序列化记录的字段见
| 字段名 | 值 | 含义 |
|---|---|---|
| [[ReplacerFunction]] | 可为对象属性提供替换值的函数(来自 JSON.stringify 的 replacer 参数)。 | |
| [[PropertyList]] | 序列化非数组对象时要包含的属性名(来自 JSON.stringify 的 replacer 参数)。 | |
| [[Gap]] | 字符串 | 缩进单位(来自 JSON.stringify 的 space 参数)。 |
| [[Stack]] | 正在序列化的嵌套对象集合。用于检测循环结构。 | |
| [[Indent]] | 字符串 | 当前缩进。 |
抽象操作 SerializeJSONProperty 接收参数 state(
抽象操作 QuoteJSONString 接收参数 value(字符串),返回一个字符串。该操作将 value 用
0x0022(引号)码元包裹,并对其中某些码元进行转义。该操作将 value 作为 UTF-16 编码的码点序列处理,详见
| 码点 | Unicode 字符名 | 转义序列 |
|---|---|---|
| U+0008 | BACKSPACE |
\b
|
| U+0009 | CHARACTER TABULATION |
\t
|
| U+000A | LINE FEED (LF) |
\n
|
| U+000C | FORM FEED (FF) |
\f
|
| U+000D | CARRIAGE RETURN (CR) |
\r
|
| U+0022 | QUOTATION MARK |
\"
|
| U+005C | REVERSE SOLIDUS |
\\
|
抽象操作 UnicodeEscape 接收参数 C(一个码元),返回一个字符串。它将 C 表示为 Unicode 转义序列。调用时执行以下步骤:
抽象操作 SerializeJSONObject 接收参数 state(一个
抽象操作 SerializeJSONArray 接收参数 state(
该属性具有属性 { [[Writable]]:
WeakRef
extends 子句中的值。希望继承指定 WeakRef 行为的子类WeakRef super 调用,以使用支持
WeakRef.prototype 内置方法所需的内部状态来创建和初始化子类实例。
该函数被调用时执行以下步骤:
WeakRef.prototype 的初始值是
该属性具有属性 { [[Writable]]:
WeakRef 原型对象:
WeakRef.prototype.constructor 的初始值为
该属性具有属性 { [[Writable]]:
该方法被调用时执行以下步骤:
如果
let target = { foo() {} };
let weakRef = new WeakRef(target);
// ... 稍后 ...
if (weakRef.deref()) {
weakRef.deref().foo();
}
在上述例子中,如果第一次 deref 的结果不是
该属性具有属性 { [[Writable]]:
抽象操作 WeakRefDeref 接收参数 weakRef(一个
该抽象操作与 WeakRef.prototype.deref 分开定义,目的是为了能够简洁地定义活性(liveness)。
FinalizationRegistry
extends 子句中的值。希望继承指定 FinalizationRegistry 行为的子类FinalizationRegistry super 调用,以使用支持
FinalizationRegistry.prototype 内置方法所需的内部状态来创建和初始化子类实例。
该函数被调用时执行以下步骤:
FinalizationRegistry.prototype 的初始值是
该属性具有属性 { [[Writable]]:
FinalizationRegistry 原型对象:
FinalizationRegistry.prototype.constructor 的初始值为
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该属性具有属性 { [[Writable]]:
接口是一组
可迭代接口
包含
实现迭代器接口的对象必须包含
| 属性 | 值 | 要求 |
|---|---|---|
|
|
一个返回 |
返回的对象必须符合 next 方法的前一次调用返回了 next 方法调用也应返回 |
参数可以传递给 next 函数,但具体解释和有效性取决于目标迭代器。for-of
语句和其他常见的迭代器使用者不会传递任何参数,因此期望以这种方式被使用的迭代器对象必须能够处理被无参调用的情况。
| 属性 | 值 | 要求 |
|---|---|---|
|
|
一个返回 |
返回的对象必须符合 next 方法调用。返回的 return 方法参数的值。但该要求不强制执行。
|
|
|
一个返回 |
返回的对象必须符合 throw 该参数。如果方法未 throw,返回的 |
通常调用这些方法前应先检查其是否存在。某些 ECMAScript 语言特性(包括
for-of、yield* 和数组解构)在调用这些方法前会做存在性检查。大多数接受
异步可迭代接口 包含
实现异步迭代器接口的对象必须包含
| 属性 | 值 | 要求 |
|---|---|---|
| 一个返回 |
返回的 promise 被 fulfill 时,必须 fulfill 为一个符合 此外,作为 fulfill 值的 |
参数可以传递给 next
函数,但具体解释和有效性取决于目标异步迭代器。for-await-of
语句和其他常见的异步迭代器使用者不会传递任何参数,因此期望以这种方式被使用的异步迭代器对象必须能够处理被无参调用的情况。
| 属性 | 值 | 要求 |
|---|---|---|
| 一个返回 |
返回的 promise 被 fulfill 时,必须 fulfill 为一个符合 此外,作为 fulfill 值的 |
|
| 一个返回 |
返回的 promise 被 fulfill 时,必须 fulfill 为一个符合 如果返回的 promise 被 fulfill, |
通常调用这些方法前应先检查其是否存在。某些 ECMAScript 语言特性(包括
for-await-of 和
yield*)在调用这些方法前会做存在性检查。
IteratorResult
接口 包含
| 属性 | 值 | 要求 |
|---|---|---|
|
|
一个布尔值 |
这是 next 方法调用的结果状态。如果已到达 |
|
|
一个 |
如果 done 为 |
迭代器辅助对象是一个
%IteratorHelperPrototype% 对象:
该属性具有属性 { [[Writable]]:
Iterator
该函数被调用时执行以下步骤:
%WrapForValidIteratorPrototype% 对象:
Iterator.prototype 的初始值是
该属性具有属性 { [[Writable]]:
Iterator 原型对象:
Iterator.prototype.constructor 是一个
[[Get]] 属性值为一个不带参数的内置函数。被调用时执行以下步骤:
[[Set]] 属性值为一个带参数 v 的内置函数。被调用时执行以下步骤:
与大多数内置原型上的
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该函数被调用时执行以下步骤:
该函数的
Iterator.prototype[%Symbol.toStringTag%] 是一个
[[Get]] 属性值为一个不带参数的内置函数。被调用时执行以下步骤:
[[Set]] 属性值为一个带参数 v 的内置函数。被调用时执行以下步骤:
与大多数内置原型上的
%AsyncIteratorPrototype% 对象:
该函数被调用时执行以下步骤:
该函数的
从同步到异步的迭代器对象 是一种
抽象操作 CreateAsyncFromSyncIterator 接收参数
syncIteratorRecord(一个
%AsyncFromSyncIteratorPrototype% 对象:
throw
方法,需要关闭它以便其有机会清理后再拒绝能力。throw 方法。
从同步到异步的
抽象操作 AsyncFromSyncIteratorContinuation 接收参数 result
(一个对象)、promiseCapability(一个
Promise 是一个用于占位最终延迟(且可能是异步)计算结果的对象。
任何 Promise 都处于三种互斥状态之一:已兑现、已拒绝 和 待定:
p 已兑现,则 p.then(f, r) 会立即入队一个 f。
p 已拒绝,则 p.then(f, r) 会立即入队一个 r。
如果 promise 不是待定的,即已兑现或已拒绝,则称其为已定型(settled)。
如果 promise 已定型,或已经“锁定”为与另一个 promise 状态一致,则称其为已解决(resolved)。尝试解决或拒绝一个已解决的 promise 无效。未解决(unresolved)的 promise 即为未 resolved 的 promise。未解决的 promise 总是处于待定状态。已解决的 promise 可以是待定、已兑现或已拒绝状态。
PromiseCapability 记录是用于封装一个
Promise 或类 Promise 对象及其可解决或拒绝该 promise 的函数的
PromiseCapability 记录拥有
| 字段名 | 值 | 含义 |
|---|---|---|
| [[Promise]] | 一个对象 | 可用作 promise 的对象。 |
| [[Resolve]] |
一个 |
用于解决该 promise 的函数。 |
| [[Reject]] |
一个 |
用于拒绝该 promise 的函数。 |
IfAbruptRejectPromise 是一组使用
等价于:
PromiseReaction 记录 是一个
PromiseReaction 记录具有
| 字段名 | 值 | 含义 |
|---|---|---|
| [[Capability]] |
一个 |
此记录为其提供响应处理器(reaction handler)的 promise 的能力。 |
| [[Type]] |
|
当 [[Handler]] 为 |
| [[Handler]] |
一个 |
应应用于传入值的函数,其返回值决定派生 promise 的后续处理。如果 [[Handler]] 为 |
抽象操作 CreateResolvingFunctions 接收参数 promise(一个 Promise),并返回一个包含 [[Resolve]](
promise reject 函数是一个匿名内置函数,具有 [[Promise]] 和 [[AlreadyResolved]] 内部槽。
当用参数 reason 调用 promise reject 函数时,执行以下步骤:
promise reject 函数的
promise resolve 函数是一个匿名内置函数,具有 [[Promise]] 和 [[AlreadyResolved]] 内部槽。
当用参数 resolution 调用 promise resolve 函数时,执行以下步骤:
promise resolve 函数的
抽象操作 FulfillPromise 接收参数 promise(一个 Promise)和
value(一个
抽象操作 NewPromiseCapability 接收参数 C(一个 resolve 和 reject 函数。promise 加上 resolve 和
reject 函数用于初始化一个新的
抽象操作 IsPromise 接收参数 x(一个
抽象操作 RejectPromise 接收参数 promise(一个 Promise)和
reason(一个
抽象操作 TriggerPromiseReactions 接收参数 reactions(一个
HostPromiseRejectionTracker 的默认实现是返回
HostPromiseRejectionTracker 在两种情况下被调用:
典型的 HostPromiseRejectionTracker 实现可能会尝试通知开发者有未处理的拒绝,同时也要注意在新处理器被添加后,如果之前的通知失效要及时通知开发者。
如果 operation 是
抽象操作 NewPromiseReactionJob 接收参数 reaction(一个
抽象操作 NewPromiseResolveThenableJob 接收参数
promiseToResolve(一个 Promise)、thenable(一个对象)、then(一个
Promise
extends 子句中的值。意图继承指定 Promise 行为的子类 super 调用
Promise Promise 与
Promise.prototype 内置方法所需的内部状态。
该函数被调用时执行以下步骤:
executor 参数必须是
传递给 executor 的 resolve 函数接受一个参数。executor 代码最终可调用 resolve,表示希望解决关联的 Promise。传递给 resolve 的参数表示延迟操作的最终值,可以是实际的兑现值,也可以是另一个 promise(如果 fulfilled)将提供值。
传递给 executor 的 reject 函数也接受一个参数。executor 代码最终可调用 reject,表示关联的 Promise 被拒绝且永远不会兑现。传递给 reject 的参数用作 promise 的拒绝值。通常应为 Error 对象。
Promise
Promise
该函数返回一个新的 promise,当传入的所有 promise 都已兑现时,其值为所有兑现值组成的数组;如果有任意一个 promise
被拒绝,则返回第一个被拒绝的原因。它在运行本算法时,会将传入的
抽象操作 GetPromiseResolve 接收参数 promiseConstructor(一个
抽象操作 PerformPromiseAll 接收参数 iteratorRecord(一个
Promise.all
Resolve Element FunctionsPromise.all
Resolve Element FunctionsPromise.all 解析元素函数Promise.all 解析元素函数是一个用于解析特定 Promise.all 元素的匿名内置函数。每个
Promise.all 解析元素函数都有 [[Index]]、[[Values]]、[[Capability]]、[[RemainingElements]] 和 [[AlreadyCalled]] 内部槽。
当以参数 x 调用 Promise.all 解析元素函数时,执行以下步骤:
Promise.all 解析元素函数的
该函数返回一个 promise,在所有原始 promise 都已定型(即已兑现或已拒绝)后,用 promise 状态快照数组兑现。它在运行本算法时,会将传入的
抽象操作 PerformPromiseAllSettled 接收参数 iteratorRecord(一个
Promise.allSettled
解析元素函数Promise.allSettled
解析元素函数Promise.allSettled
拒绝元素函数Promise.allSettled
拒绝元素函数Promise.allSettled 解析元素函数Promise.allSettled 解析元素函数是一个匿名内置函数,用于解析特定的 Promise.allSettled
元素。每个 Promise.allSettled 解析元素函数都有 [[Index]]、[[Values]]、[[Capability]]、[[RemainingElements]] 和 [[AlreadyCalled]] 内部槽。
当以参数 x 调用 Promise.allSettled 解析元素函数时,执行以下步骤:
Promise.allSettled 解析元素函数的
Promise.allSettled 拒绝元素函数Promise.allSettled 拒绝元素函数是一个匿名内置函数,用于拒绝特定的 Promise.allSettled
元素。每个 Promise.allSettled 拒绝元素函数都有 [[Index]]、[[Values]]、[[Capability]]、[[RemainingElements]] 和 [[AlreadyCalled]] 内部槽。
当以参数 x 调用 Promise.allSettled 拒绝元素函数时,执行以下步骤:
Promise.allSettled 拒绝元素函数的
该函数返回一个 promise,该 promise 会被第一个兑现的输入 promise 兑现,或者如果所有输入 promise 都被拒绝,则以包含所有拒绝原因的
AggregateError 拒绝。在执行本算法时,会将传入的
抽象操作 PerformPromiseAny 接收参数 iteratorRecord(一个
Promise.any
拒绝元素函数Promise.any
拒绝元素函数Promise.any 拒绝元素函数
Promise.any 拒绝元素函数是一个匿名内置函数,用于拒绝特定的 Promise.any 元素。每个
Promise.any 拒绝元素函数都有 [[Index]]、
[[Errors]]、[[Capability]]、[[RemainingElements]] 和 [[AlreadyCalled]] 内部槽。
当以参数 x 调用 Promise.any 拒绝元素函数时,执行以下步骤:
Promise.any 拒绝元素函数的
Promise.prototype 的初始值为
该属性具有属性 { [[Writable]]:
该函数返回一个新的 promise,其定型方式与第一个定型的输入 promise 相同。在运行本算法时会把传入的 iterable 的所有元素解析为 promise。
如果 iterable 参数不产出任何值,或者由 iterable 产出的 promise 都不会定型,则该方法返回的待定 promise 将永远不会定型。
抽象操作 PerformPromiseRace 接收参数 iteratorRecord(一个
该函数返回一个以传入参数为拒绝原因的新 promise。
该函数返回一个用传入参数解决的新 promise,或者如果参数本身就是由该
抽象操作 PromiseResolve 接收参数 C(一个对象)和
x(一个
该函数被调用时执行以下步骤:
该函数返回一个包含三个属性的对象:一个新的 promise,以及与其关联的 resolve 和 reject 函数。
Promise[%Symbol.species%] 是一个
该函数的
Promise 原型方法通常使用其
Promise 原型对象:
该方法被调用时执行以下步骤:
Promise.prototype.constructor 的初始值为
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
抽象操作 PerformPromiseThen 接收参数 promise(一个 Promise),
onFulfilled(一个
该属性具有属性 { [[Writable]]:
Promise 实例是
| 内部槽 | 类型 | 描述 |
|---|---|---|
| [[PromiseState]] |
|
控制 promise 对其 then 方法的调用如何反应。
|
| [[PromiseResult]] |
一个 |
promise 被兑现或拒绝时的值(如果有)。仅当 [[PromiseState]] 为
|
| [[PromiseFulfillReactions]] |
一个 |
|
| [[PromiseRejectReactions]] |
一个 |
|
| [[PromiseIsHandled]] | 布尔值 | 指示 promise 是否曾经有过兑现或拒绝处理器;用于未处理拒绝的追踪。 |
GeneratorFunction 通常是通过求值
GeneratorFunction
Function 的子类。GeneratorFunction (…) 等价于用相同参数的对象创建表达式 new GeneratorFunction (…)。
extends 子句的值。意图继承指定 GeneratorFunction 行为的子类 super 调用 GeneratorFunction 最后一个参数(如果有)指定生成器函数的主体(可执行代码);之前的所有参数指定形式参数。
该函数被调用时执行以下步骤:
参见
GeneratorFunction
GeneratorFunction.prototype 的初始值为
该属性具有属性 { [[Writable]]:
GeneratorFunction 原型对象:
GeneratorFunction.prototype.constructor 的初始值为
该属性具有属性 { [[Writable]]:
GeneratorFunction.prototype.prototype 的初始值为
该属性具有属性 { [[Writable]]:
该属性具有属性 { [[Writable]]:
每个 GeneratorFunction 实例都是一个 ECMAScript
每个 GeneratorFunction 实例拥有以下自有属性:
Function 实例的
Function 实例的
每当创建一个 GeneratorFunction 实例时,还会创建另一个
该属性具有属性 { [[Writable]]:
与 Function 实例不同,GeneratorFunction 的
AsyncGeneratorFunction 通常是通过求值
AsyncGeneratorFunction
Function 的子类。AsyncGeneratorFunction (...) 等价于用相同参数的对象创建表达式
new AsyncGeneratorFunction (...)。
extends 子句的值。意图继承指定 AsyncGeneratorFunction 行为的子类 super 调用 AsyncGeneratorFunction 最后一个参数(如果有)指定异步生成器函数的主体(可执行代码);之前的所有参数指定形式参数。
该函数被调用时执行以下步骤:
参见
AsyncGeneratorFunction
AsyncGeneratorFunction.prototype 的初始值为
该属性具有属性 { [[Writable]]:
AsyncGeneratorFunction 原型对象:
AsyncGeneratorFunction.prototype.constructor 的初始值为
该属性具有属性 { [[Writable]]:
AsyncGeneratorFunction.prototype.prototype 的初始值为
该属性具有属性 { [[Writable]]:
该属性具有属性 { [[Writable]]:
每个 AsyncGeneratorFunction 实例都是一个 ECMAScript
每个 AsyncGeneratorFunction 实例拥有以下自有属性:
该属性具有属性 { [[Writable]]:
Function 实例的
每当创建一个 AsyncGeneratorFunction 实例时,还会创建另一个
该属性具有属性 { [[Writable]]:
与普通 Function 实例不同,AsyncGeneratorFunction 的
Generator 是通过调用生成器函数创建的,同时符合
Generator 实例直接继承自创建该实例的生成器函数的
%GeneratorPrototype% 对象:
.constructor
的初始值为
该属性具有属性 { [[Writable]]:
该方法被调用时执行以下步骤:
该方法被调用时执行以下步骤:
该属性具有属性 { [[Writable]]:
Generator 实例最初使用
| 内部槽 | 类型 | 描述 |
|---|---|---|
| [[GeneratorState]] |
|
当前 generator 的执行状态。 |
| [[GeneratorContext]] |
一个 |
执行该 generator 代码时所用的 |
| [[GeneratorBrand]] |
字符串或 |
用于区分不同类型 generator 的标记。由 |
抽象操作 GeneratorStart 接收参数 generator(一个 Generator)和 generatorBody(
抽象操作 GeneratorValidate 接收参数 generator(一个
抽象操作 GeneratorResume 接收参数 generator(一个
抽象操作 GeneratorResumeAbrupt 接收参数 generator(一个
抽象操作 GetGeneratorKind 不带参数,返回
抽象操作 GeneratorYield 接收参数 iteratorResult(一个符合
抽象操作 Yield 接收参数 value(一个
抽象操作 CreateIteratorFromClosure 接收参数 closure(一个无参数的
AsyncGenerator 是通过调用异步生成器函数创建的,并同时符合
AsyncGenerator 实例直接继承自创建该实例的异步生成器函数
%AsyncGeneratorPrototype% 对象:
.constructor
的初始值为
该属性具有属性 { [[Writable]]:
该属性具有属性 { [[Writable]]:
AsyncGenerator 实例最初使用如下内部槽创建:
| 内部槽 | 类型 | 描述 |
|---|---|---|
| [[AsyncGeneratorState]] | 当前异步生成器的执行状态。 | |
| [[AsyncGeneratorContext]] | 一个 |
执行该异步生成器代码时所用的 |
| [[AsyncGeneratorQueue]] | 一个 |
|
| [[GeneratorBrand]] | 字符串或 |
用于区分不同类型异步生成器的标记。由 |
AsyncGeneratorRequest 是一个
它们具有以下字段:
| 字段名 | 值 | 含义 |
|---|---|---|
| [[Completion]] | 一个 |
用于恢复异步生成器的 |
| [[Capability]] | 一个 |
与该请求关联的 promise 能力。 |
抽象操作 AsyncGeneratorStart 接收参数 generator(一个 AsyncGenerator)和
generatorBody(
抽象操作 AsyncGeneratorValidate 接收参数 generator(一个
抽象操作 AsyncGeneratorEnqueue 接收参数 generator(一个
AsyncGenerator)、completion(一个
抽象操作 AsyncGeneratorCompleteStep 接收参数 generator(一个
AsyncGenerator)、completion(一个
抽象操作 AsyncGeneratorResume 接收参数 generator(一个 AsyncGenerator)和
completion(一个
抽象操作 AsyncGeneratorUnwrapYieldResumption 接收参数 resumptionValue(一个
抽象操作 AsyncGeneratorYield 接收参数 value(一个
抽象操作 AsyncGeneratorAwaitReturn 接收参数 generator(一个 AsyncGenerator),返回
抽象操作 AsyncGeneratorDrainQueue 接收参数 generator(一个 AsyncGenerator),返回
抽象操作 CreateAsyncIteratorFromClosure 接收参数 closure(一个无参数的
AsyncFunction 通常是通过求值
AsyncFunction
Function 的子类。AsyncFunction(…) 等价于用相同参数的对象创建表达式 new AsyncFunction(…)。
extends 子句的值。意图继承指定 AsyncFunction 行为的子类 super 调用
AsyncFunction 最后一个参数(如果有)指定异步函数的函数体(可执行代码);之前的所有参数指定形式参数。
该函数被调用时执行以下步骤:
AsyncFunction
AsyncFunction.prototype 的初始值为
该属性具有属性 { [[Writable]]:
AsyncFunction 原型对象:
AsyncFunction.prototype.constructor 的初始值为
该属性具有属性 { [[Writable]]:
该属性具有属性 { [[Writable]]:
每个 AsyncFunction 实例都是一个 ECMAScript
每个 AsyncFunction 实例拥有以下自有属性:
Function 实例的
Function 实例的
抽象操作 AsyncFunctionStart 接收参数 promiseCapability(一个
抽象操作 AsyncBlockStart 接收参数 promiseCapability(一个
抽象操作 Await 接收参数 value(一个
Reflect 对象:
new 操作符一起使用。
该函数被调用时执行以下步骤:
该函数被调用时执行以下步骤:
该函数被调用时执行以下步骤:
该函数被调用时执行以下步骤:
该函数被调用时执行以下步骤:
该函数被调用时执行以下步骤:
该函数被调用时执行以下步骤:
该函数被调用时执行以下步骤:
该函数被调用时执行以下步骤:
该函数被调用时执行以下步骤:
该函数被调用时执行以下步骤:
该函数被调用时执行以下步骤:
该函数被调用时执行以下步骤:
该属性具有属性 { [[Writable]]:
Proxy
该函数被调用时执行以下步骤:
Proxy
该函数用于创建一个可撤销的 Proxy 对象。
被调用时执行以下步骤:
模块命名空间对象是一个
除了
该属性具有属性 { [[Writable]]:
内存一致性模型,或称内存模型,规定了通过访问由 SharedArrayBuffer 支持的
内存模型被定义为对由
共享内存的访问(读和写)分为两组,原子访问和数据访问,定义见下。原子访问是顺序一致的,即,在一个
不支持比顺序一致更弱、比无序更强的顺序(如 release-acquire)。
共享数据块事件 是 ReadSharedMemory、WriteSharedMemory 或 ReadModifyWriteSharedMemory
| 字段名 | 值 | 含义 |
|---|---|---|
| [[Order]] | 内存模型为该事件保证的最弱顺序。 | |
| [[NoTear]] | 布尔值 | 该事件是否允许从与本事件范围相等的多个写事件中读取。 |
| [[Block]] | 一个 |
事件所操作的块。 |
| [[ByteIndex]] | 非负 |
在 [[Block]] 中读操作的字节地址。 |
| [[ElementSize]] | 非负 |
读操作的大小。 |
| 字段名 | 值 | 含义 |
|---|---|---|
| [[Order]] | 读-改-写事件总是顺序一致的。 | |
| [[NoTear]] | 读-改-写事件不允许撕裂。 | |
| [[Block]] | 一个 |
事件所操作的块。 |
| [[ByteIndex]] | 非负 |
在 [[Block]] 中读-改-写操作的字节地址。 |
| [[ElementSize]] | 非负 |
读-改-写操作的大小。 |
| [[Payload]] | 一个 |
将被传递给 [[ModifyOp]] 的 |
| [[ModifyOp]] | 一个 |
一个抽象闭包,接收读到的 |
这些事件由
某些操作还可能引入 Synchronize 事件。Synchronize 事件 没有字段,仅用于直接约束其它事件允许的顺序。
除了
设 ReadSharedMemory、WriteSharedMemory 或 ReadModifyWriteSharedMemory 事件的范围为其 [[ByteIndex]] 到 [[ByteIndex]] + [[ElementSize]] - 1 的连续
事件在
Agent 事件记录是一个带有以下字段的
| 字段名 | 值 | 含义 |
|---|---|---|
| [[AgentSignifier]] | 一个 |
进行该排序的 |
| [[EventList]] | 一个事件 |
事件在求值期间被添加到该列表。 |
| [[AgentSynchronizesWith]] | 一个 |
操作语义引入的 |
选定值记录是一个带有以下字段的
| 字段名 | 值 | 含义 |
|---|---|---|
| [[Event]] | 一个 |
为该选定值引入的 |
| [[ChosenValue]] | 一个 |
在求值期间非确定性选定的字节。 |
候选执行是对
| 字段名 | 值 | 含义 |
|---|---|---|
| [[EventsRecords]] | 一个 |
将一个 |
| [[ChosenValues]] | 一个 |
将 |
抽象操作 EventSet 接收参数 execution(一个
抽象操作 SharedDataBlockEventSet 接收参数 execution(一个
抽象操作 HostEventSet 接收参数 execution(一个
抽象操作 ComposeWriteEventBytes 接收参数 execution(一个
读-改-写的修改 [[ModifyOp]] 由 Atomics 对象上的相应函数属性决定,这些属性会引入
该抽象操作将若干写事件合成为一个
抽象操作 ValueOfReadEvent 接收参数 execution(一个
以下关系和数学函数以某个
对于一个
对于一个
对于
每个
对于一个
对于一个
对于
对于一个
根据内存模型文献的惯例,在
在
在
对于
对于一个
对于事件 E 和 D,如果以下任一条件成立,则 E happens-before D:
当事件通过访问
直观上,这一要求意味着当通过
对于
对于 R 和 W,若 R
该条款进一步约束了等范围上的
对于
虽然 is-memory-order-before 覆盖
所有程序至少有一个有效执行。
对于执行 execution 以及其中
对于执行 execution 以及其中
若
若程序的所有执行均为数据竞争自由,则称该程序为数据竞争自由程序。
以下是 ECMAScript 程序员使用共享内存的指南。
我们建议程序保持
更一般地说,即使程序不是
以下是 ECMAScript 实现者为使用共享内存的程序编写编译器转换的指南。
建议在多
设agent-order 片段为
设一次读事件的可能读取值为该事件在所有有效执行中
任何在无共享内存时有效的 agent-order 片段转换,在有共享内存时也是有效的,但有如下例外:
原子操作不可变:程序转换不得导致 agent-order 片段内
(实际上,对重排序的禁止要求编译器假定每个
读取必须稳定:每个共享内存读取在一次执行中只能观察到一个值。
(例如,若程序语义上某次读取被多次执行,则程序只能观察到这些读取值中的一个。rematerialization 转换可能违反此规则。)
写入必须稳定:所有可观察到的共享内存写入都必须由程序语义产生。
(例如,转换不能引入某些可观察写,如对更大位置的读-改-写操作来写入较小数据,写入程序本不可写的值,或对刚读取的位置写回刚读取的值,如果该位置在读取后可能被其他
可能读取值非空:程序转换不能导致共享内存读取的可能读取值集合为空。
(反直觉地,本规则实际上限制了写入的变换,因为写入只有被读取事件读取时才有意义。例如,写入可以移动、合并,有时可在两个
以下转换仍然有效:合并同一位置的多个非原子读取、重排序非原子读取、引入推测性非原子读取、合并同一位置的多个非原子写、重排序对不同位置的非原子写、将非原子读取抽出循环(即使影响终止)。注意,别名
以下是 ECMAScript 实现者为共享内存访问生成机器码的指南。
对于内存模型不弱于 ARM 或 Power
的体系结构,非原子存储和加载可直接编译为目标架构上的存储和加载指令。原子存储和加载可编译为保证顺序一致性的指令。如果没有这样的指令,则应使用内存屏障,例如在存储或加载两侧加屏障。读-改-写操作可编译为目标架构上的原子读-改-写指令,如
x86 的 LOCK 前缀指令、ARM 的 load-exclusive/store-exclusive、Power 的
load-link/store-conditional。
具体而言,
朴素的代码生成模式如下:
只要某地址范围上的原子操作不与非原子写或不同尺寸的原子操作竞争,上述映射就是正确的。这已足够:
在遵守
LOCK 前缀。在许多平台,存在多种强度的屏障,在某些情况下可用弱屏障而不破坏顺序一致性。
当处理如下产生式的一个实例时
对
当处理如下产生式的一个实例时
对
在处理如下产生式的某些情况下
对
当处理如下产生式的一个实例时
对
当处理如下产生式的一个实例时
对
所有未被
每个 \u u \u u
当 ECMAScript
本附录描述了 Web 浏览器 ECMAScript
这些特性不被认为是 ECMAScript 核心语言的一部分。编写新的 ECMAScript 代码时,程序员不应使用或假定这些特性和行为的存在。除非实现是 Web 浏览器的一部分,或需要运行 Web 浏览器所遇到的相同遗留 ECMAScript 代码,否则不建议 ECMAScript 实现实现这些特性。
类似于包含行终止符代码点的
这种可选的模式文法和语义仅更改了 BMP 模式的语法和语义。下列文法扩展包含带有 [UnicodeMode] 参数的产生式。然而,这些扩展并不会更改在
当同一个左侧出现了带有 [+UnicodeMode] 和 [~UnicodeMode] 条件时,这是用于控制消歧优先级。
此外,以下产生式的规则通过添加高亮文本被修改:
在
\(U+005C,反斜杠)的 以下两条规则替换了
此外,以下规则被添加到
\(U+005C,反斜杠)的 \c 序列且其后不跟可接受的控制字符时被匹配到。抽象操作 CharacterRangeOrUnion 接收参数 rer(一个
抽象操作
当 ECMAScript
| 内在名称 | 全局名称 | ECMAScript 语言关联 |
|---|---|---|
|
|
escape
|
escape 函数 ( |
|
|
unescape
|
unescape 函数 ( |
此函数是
当替换数值小于等于 0x00FF 的码元时,使用形如 %xx 的两位转义序列。当替换数值严格大于 0x00FF 的码元时,使用形如
%uxxxx 的四位转义序列。
它是 %escape% 内在对象。
调用时执行以下步骤:
该编码部分基于 RFC 1738 中描述的编码,但本标准中描述的完整编码如上所述,不考虑 RFC 1738 的内容。此编码未反映 RFC 3986 对 RFC 1738 的更改。
此函数是 escape 函数引入的转义序列替换为其所代表的码元。
它是 %unescape% 内在对象。
调用时执行以下步骤:
该方法返回将
调用时执行以下步骤:
该方法本身是通用的;它不要求
此方法被调用时执行以下步骤:
抽象操作 CreateHTML 接收参数 string(
此方法被调用时执行以下步骤:
此方法被调用时执行以下步骤:
此方法被调用时执行以下步骤:
此方法被调用时执行以下步骤:
此方法被调用时执行以下步骤:
此方法被调用时执行以下步骤:
此方法被调用时执行以下步骤:
此方法被调用时执行以下步骤:
此方法被调用时执行以下步骤:
此方法被调用时执行以下步骤:
此方法被调用时执行以下步骤:
此方法被调用时执行以下步骤:
推荐使用
推荐使用
在几乎所有场合都推荐使用 getFullYear 方法,因为它避免了“千年虫问题”。
该方法被调用时执行以下步骤:
在几乎所有场合都推荐使用 setFullYear 方法,因为它避免了“千年虫问题”。
该方法被调用时执行以下步骤:
推荐使用 toUTCString 方法。本方法主要为了兼容旧代码而保留。
此方法被调用时执行以下步骤:
该方法会完全重新初始化
在 ECMAScript 2015 之前,
在 ECMAScript 2015 之前,ECMAScript 规范没有定义
函数在单个块内声明且仅在该块内被引用。
var 声明的 f。
函数在单个
var 声明的 f。
函数在单个块内声明并可能被使用,但也在后续块内被引用。
var 声明的 f。
第一个用例与 ECMAScript 2015 提供的块级函数声明语义兼容。任何采用该用例的现有
第二和第三个用例的 ECMAScript 2015 兼容性需要对
如果 ECMAScript 实现有报告诊断警告信息的机制,当代码包含应用了这些兼容性语义且与非兼容性语义产生可观察差异的
在
在
在
在
switch 语句静态语义:早期错误的变更在
在
在
下述内容对
该产生式仅适用于解析
子条款
var 声明。在运行时,这些绑定会在 VariableDeclarationEnvironment 中实例化。它们不会遮蔽由 var 声明的 var 绑定。
这种修改后的行为也适用于 var 和 function 声明。这一更改是通过如下方式修改
第
第
下列内容补充了
该产生式仅在解析
在
在
在
[[IsHTMLDDA]] 内部槽 可能存在于 typeof 运算符
具有 [[IsHTMLDDA]] 内部槽的对象不会由本规范创建。但 Web 浏览器中的 document.all
对象 是一个带有此槽的 document.all 外,实现不应创建任何此类对象。
以下步骤替换
typeof 运算符的更改以下步骤替换
严格模式的限制与例外
implements、interface、let、package、
private、protected、public、static 和
yield 在 TypeError 异常(arguments
与 arguments 对象的绑定是不可变的,因此不能作为赋值表达式的目标。(Function.prototype.apply 和 Function.prototype.call)传递的
delete 运算符出现在 delete 运算符出现在 eval 或 arguments,则为 [[HostDefined]] 在
[[HostDefined]] 在
[[HostDefined]] 在
[[HostDefined]] 在
[[HostSynchronizesWith]] 在候选执行上:见
[[IsHTMLDDA]]:见
主机环境可自由定义错误消息内容及格式。本规范无特殊要求。
Date.prototype.toString 返回的值。ECMAScript 2015 指定返回字符串值
/。
String.prototype.match
和 String.prototype.replace 的规范对于参数为带有 global 标志的 RegExp
情况是不正确的。之前规范声明每次尝试匹配时,如果 lastIndex 未改变,则应将其加1。正确行为是仅当模式匹配空字符串时才将 lastIndex 加1。
Array.prototype.sort 如何处理。ECMAScript 2015 指定该值视作从比较器返回了
Space_Separator (Zs) category and thus treated as whitespace in ECMAScript
2015, to be moved to the Format (Cf) category (as of Unicode 6.3.0). This
causes whitespace-sensitive methods to behave differently. For example,
"\u180E".trim().length was 0 in previous editions, but 1 in
ECMAScript 2016 and later. Additionally, ECMAScript 2017 mandated always using the latest version of the
Unicode Standard.
let followed by the token [ is the start of a
(
token of a for statement is immediately followed by the token sequence let [ then the
let is treated as the start of a
let [ then the
let is treated as the start of a
in
var declaration for the same
eval
whose eval code includes a var or FunctionDeclaration declaration that binds
the same
Object.freeze is not an object it is treated as if
it was a non-extensible
Object.getOwnPropertyDescriptor is not an object an attempt is made to coerce
the argument using
Object.getOwnPropertyNames is not an object an attempt is made to coerce the
argument using
Object.getPrototypeOf is not an object an attempt is made to coerce the argument using
Object.isExtensible is not an object it is treated as if it was a non-extensible
Object.isFrozen is not an object it is treated as if it was a non-extensible
Object.isSealed is not an object it is treated as if it was a non-extensible
Object.keys is not an object an attempt is made to
coerce the argument using
Object.preventExtensions is not an object it is treated as if it was a
non-extensible
Object.seal is not an object it is treated as if it was
a non-extensible
String.prototype.localeCompare function must treat Strings that are canonically equivalent
according to the Unicode Standard as being identical. In previous editions implementations were
permitted to ignore canonical equivalence and could instead use a bit-wise comparison.
String.prototype.trim method is defined to recognize white space code points that may exist
outside of the Unicode BMP. However, as of Unicode 7 no such code points are defined. In previous
editions such code points would not have been recognized as white space.
Atomics.wake has been renamed to Atomics.notify to prevent
confusion with Atomics.wait.
await
was reduced, which could create an observable difference in resolution order between a
then() call and an await expression.
There are no normative changes between IEEE 754-2008 and IEEE 754-2019 that affect the ECMA-262 specification.
Script Property, available at <https://unicode.org/reports/tr24/>
This specification is authored on GitHub in a plaintext source format called Ecmarkup. Ecmarkup is an HTML and Markdown dialect that provides a framework and toolset for authoring ECMAScript specifications in plaintext and processing the specification into a full-featured HTML rendering that follows the editorial conventions for this document. Ecmarkup builds on and integrates a number of other formats and technologies including Grammarkdown for defining syntax and Ecmarkdown for authoring algorithm steps. PDF renderings of this specification are produced using a print stylesheet which takes advantage of the CSS Paged Media specification and is converted using PrinceXML.
Prior editions of this specification were authored using Word—the Ecmarkup source text that formed the basis of this edition was produced by converting the ECMAScript 2015 Word document to Ecmarkup using an automated conversion tool.
Ecma International
Rue du Rhone 114
CH-1204 Geneva
Tel: +41 22 849 6000
Fax: +41 22 849 6001
Web: https://ecma-international.org/
© 2025 Ecma International
This draft document may be copied and furnished to others, and derivative works that comment on or otherwise explain it or assist in its implementation may be prepared, copied, published, and distributed, in whole or in part, without restriction of any kind, provided that the above copyright notice and this section are included on all such copies and derivative works. However, this document itself may not be modified in any way, including by removing the copyright notice or references to Ecma International, except as needed for the purpose of developing any document or deliverable produced by Ecma International.
This disclaimer is valid only prior to final version of this document. After approval all rights on the standard are reserved by Ecma International.
The limited permissions are granted through the standardization phase and will not be revoked by Ecma International or its successors or assigns during this time.
This document and the information contained herein is provided on an "AS IS" basis and ECMA INTERNATIONAL DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY OWNERSHIP RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
All Software contained in this document ("Software") is protected by copyright and is being made available under the "BSD License", included below. This Software may be subject to third party rights (rights from parties other than Ecma International), including patent rights, and no licenses under such third party rights are granted under this license even if the third party concerned is a member of Ecma International. SEE THE ECMA CODE OF CONDUCT IN PATENT MATTERS AVAILABLE AT https://ecma-international.org/memento/codeofconduct.htm FOR INFORMATION REGARDING THE LICENSING OF PATENT CLAIMS THAT ARE REQUIRED TO IMPLEMENT ECMA INTERNATIONAL STANDARDS.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
THIS SOFTWARE IS PROVIDED BY THE ECMA INTERNATIONAL "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ECMA INTERNATIONAL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.